python-opencv 垫片缺陷检测

曾经终败给现在 2023-06-15 11:01 22阅读 0赞

import cv2
    import numpy as np
    # 8 后座表面有色斑
    im = cv2.imread("img/8.bmp")
    im_o = cv2.resize(im, (800, 600))
    
    im_gauss = cv2.cvtColor(im_o, cv2.COLOR_RGB2GRAY)
    im_gauss = cv2.GaussianBlur(im_gauss, (7, 7), 0)
    ret, im = cv2.threshold(im_gauss, 30, 255, 0)
    cv2.imshow("o", im)
    # Setup SimpleBlobDetector parameters.
    params = cv2.SimpleBlobDetector_Params()
    
    # Change thresholds
    params.minThreshold = 10
    params.maxThreshold = 200
    
    # Filter by Area.
    params.filterByArea = True
    # 过滤掉小于像素16的区域
    params.minArea = 16
    
    # Filter by Circularity
    params.filterByCircularity = True
    # 设置类圆性
    params.minCircularity = 0.3
    
    # Filter by Convexity
    params.filterByConvexity = True
    # 设置最小凸性
    params.minConvexity = 0.67  #0.57
    
    # Filter by Inertia
    params.filterByInertia = True
    # 测量了一个形状有多长：对于一个圆，这个值是1，对于一个椭圆，它在0到1之间，对于一条直线，它是0
    params.minInertiaRatio = 0.01
    
    # Create a detector with the parameters
    ver = (cv2.__version__).split('.')
    if int(ver[0]) < 3:
        detector = cv2.SimpleBlobDetector(params)
    else:
        detector = cv2.SimpleBlobDetector_create(params)
    
    # Detect blobs.
    keypoints = detector.detect(im)
    
    # Draw detected blobs as red circles.
    # cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS ensures
    # the size of the circle corresponds to the size of blob
    
    im_with_keypoints = cv2.drawKeypoints(im_o, keypoints, np.array([]), (0, 0, 255),
                                          cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
    
    # Show blobs
    cv2.imshow("Keypoints", im_with_keypoints)
    cv2.waitKey(0)

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy_size_16_color_FFFFFF_t_70 1]

import numpy as np
    import cv2
    import matplotlib.pyplot as plt
    # 2 铝垫圈表面压伤
    image = cv2.imread("img/2.bmp", 0)
    image1 = cv2.imread("img/2.bmp")
    image2 = cv2.resize(image, (800, 600))
    cv2.imshow('image1', image2)
    
    # 定义两个圆形
    circle1 = np.zeros(image.shape[0:2], dtype="uint8")
    cv2.circle(circle1, (625, 500), 210, 255, -1)
    circle2 = np.zeros(image.shape[0:2], dtype="uint8")
    # cv2.circle(circle2, (625, 505), 284, 255, -1)
    cv2.circle(circle2, (625, 505), 252, 255, -1)
    
    # 异或运算,通过两个圆建立一个圆环作为掩膜
    bitwiseXor = cv2.bitwise_xor(circle1, circle2)
    mask = bitwiseXor
    # cv2.imshow('Mask', mask)
    
    # 将掩膜应用于原图
    masked = cv2.bitwise_and(image, image, mask=mask)
    # cv2.imshow('Mask applied to Image', masked)
    # cv2.waitKey(0)
    
    # 高斯滤波
    im_o = cv2.resize(masked, (800, 600))
    im_gauss = cv2.GaussianBlur(masked, (3, 3), 0)
    
    # Canny算子
    canny = cv2.Canny(im_gauss, 120, 240)
    canny1 = cv2.resize(canny, (800, 600))
    cv2.imshow('Canny', canny1)
    
    # 1.image 不用多说，输入矩阵
    # 2.method cv2.HOUGH_GRADIENT 也就是霍夫圆检测，梯度法
    # 3.dp 计数器的分辨率图像像素分辨率与参数空间分辨率的比值（官方文档上写的是图像分辨率与累加器分辨率的比值，它把参数空间认为是一个累加器，毕竟里面存储的都是经过的像素点的数量），dp=1，则参数空间与图像像素空间（分辨率）一样大，dp=2，参数空间的分辨率只有像素空间的一半大
    # 4.minDist 圆心之间最小距离，如果距离太小，会产生很多相交的圆，如果距离太大，则会漏掉正确的圆
    # 5.param1 canny检测的双阈值中的高阈值，低阈值是它的一半
    # 6.param2 最小投票数（基于圆心的投票数）
    # 7.minRadius 需要检测圆的最小半径
    # 8.maxRadius 需要检测圆的最大半径
    circles = cv2.HoughCircles(canny, cv2.HOUGH_GRADIENT, 1, 10, param1=240, param2=10, minRadius=2, maxRadius=50)
    circles = np.uint16(np.around(circles))  # 四舍五入，取整
    
    for i in circles[0, :]:
        cv2.circle(image1, (i[0], i[1]), i[2], (0, 0, 255), 2)  # 画圆
        # cv2.circle(image, (i[0], i[1]), 2, (255, 0, 255), 10) # 画圆心
    
    image2 = cv2.resize(image1, (800, 600))
    cv2.imshow("HoughCircle", image2)
    cv2.waitKey(0)
    # cv2.destroyAllWindows()
    # plt.subplot(121), plt.imshow(canny, 'gray')
    # plt.title('img'), plt.xticks([]), plt.yticks([])
    # plt.subplot(122), plt.imshow(im_gauss, 'gray')
    # plt.title('img'), plt.xticks([]), plt.yticks([])
    # plt.show()
    
    
    # cv2.imshow('image',image)
    # cv2.waitKey(0)
    # cv2.destroyAllWindows()

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy_size_16_color_FFFFFF_t_70 2]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy_size_16_color_FFFFFF_t_70 3]

import numpy as np
    import cv2
    import matplotlib.pyplot as plt
    # 1 铝垫圈外径顶角有缺料现象
    image = cv2.imread("img/1.bmp", 0)
    image1 = cv2.imread("img/1.bmp")
    image2 = cv2.resize(image, (800, 600))
    cv2.imshow('image1', image2)
    
    # 定义两个圆形
    circle1 = np.zeros(image.shape[0:2], dtype="uint8")
    cv2.circle(circle1, (633, 543), 249, 255, -1)
    circle2 = np.zeros(image.shape[0:2], dtype="uint8")
    # cv2.circle(circle2, (625, 505), 284, 255, -1)
    cv2.circle(circle2, (633, 543), 259, 255, -1)
    
    # 异或运算,通过两个圆建立一个圆环作为掩膜
    bitwiseXor = cv2.bitwise_xor(circle1, circle2)
    mask = bitwiseXor
    # cv2.imshow('Mask', mask)
    
    # 将掩膜应用于原图
    masked = cv2.bitwise_and(image, image, mask=mask)
    # cv2.imshow('Mask applied to Image', masked)
    
    # 高斯滤波
    im_o = cv2.resize(masked, (800, 600))
    im_gauss = cv2.GaussianBlur(masked, (3, 3), 0)
    ret, im = cv2.threshold(im_gauss, 60, 255, 0)
    cv2.imshow('threshold', im)
    
    # 开运算：先腐蚀，后膨胀
    kernel = np.ones((3, 3), np.uint8)
    opening = cv2.morphologyEx(im, cv2.MORPH_OPEN, kernel)
    opening = cv2.morphologyEx(opening, cv2.MORPH_OPEN, kernel)
    # cv2.imshow('open', opening)
    
    # Canny算子
    canny = cv2.Canny(opening, 100, 200)
    canny1 = cv2.resize(canny, (800, 600))
    cv2.imshow('Canny', canny1)
    
    # 1.image 不用多说，输入矩阵
    # 2.method cv2.HOUGH_GRADIENT 也就是霍夫圆检测，梯度法
    # 3.dp 计数器的分辨率图像像素分辨率与参数空间分辨率的比值（官方文档上写的是图像分辨率与累加器分辨率的比值，它把参数空间认为是一个累加器，毕竟里面存储的都是经过的像素点的数量），dp=1，则参数空间与图像像素空间（分辨率）一样大，dp=2，参数空间的分辨率只有像素空间的一半大
    # 4.minDist 圆心之间最小距离，如果距离太小，会产生很多相交的圆，如果距离太大，则会漏掉正确的圆
    # 5.param1 canny检测的双阈值中的高阈值，低阈值是它的一半
    # 6.param2 最小投票数（基于圆心的投票数）
    # 7.minRadius 需要检测圆的最小半径
    # 8.maxRadius 需要检测圆的最大半径
    circles = cv2.HoughCircles(canny, cv2.HOUGH_GRADIENT, 1, 10, param1=200, param2=5, minRadius=6, maxRadius=11)
    circles = np.uint16(np.around(circles))  # 四舍五入，取整
    
    for i in circles[0, :]:
        cv2.circle(image1, (i[0], i[1]), i[2], (0, 0, 255), 2)  # 画圆
        # cv2.circle(image, (i[0], i[1]), 2, (255, 0, 255), 10) # 画圆心
    
    image2 = cv2.resize(image1, (800, 600))
    cv2.imshow("HoughCircle", image2)
    cv2.waitKey(0)

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy_size_16_color_FFFFFF_t_70 4]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy_size_16_color_FFFFFF_t_70 5]

import cv2
    import numpy as np
    # 4 M12螺纹导向处有碰伤
    image = cv2.imread("img/4.bmp")
    image1 = cv2.resize(image, (800, 600))
    image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    cv2.imshow('image1', image1)
    
    # 定义两个圆形
    circle1 = np.zeros(image.shape[0:2], dtype="uint8")
    cv2.circle(circle1, (628, 493), 211, 255, -1)
    circle2 = np.zeros(image.shape[0:2], dtype="uint8")
    # cv2.circle(circle2, (625, 505), 284, 255, -1)
    cv2.circle(circle2, (628, 493), 256, 255, -1)
    
    # 异或运算,通过两个圆建立一个圆环作为掩膜
    bitwiseXor = cv2.bitwise_xor(circle1, circle2)
    mask = bitwiseXor
    # cv2.imshow('Mask', mask)
    
    # 将掩膜应用于原图
    masked = cv2.bitwise_and(image, image, mask=mask)
    # cv2.imshow('Mask applied to Image', masked)
    
    
    im_o = cv2.resize(masked, (800, 600))
    im_gauss = cv2.GaussianBlur(im_o, (7, 7), 0)
    ret, im = cv2.threshold(im_gauss, 180, 255, 0)
    # cv2.imshow("o", im)
    
    canny = cv2.Canny(im, 64, 128)
    cv2.imshow('Canny', canny)
    
    # 1.image 不用多说，输入矩阵
    # 2.method cv2.HOUGH_GRADIENT 也就是霍夫圆检测，梯度法
    # 3.dp 计数器的分辨率图像像素分辨率与参数空间分辨率的比值（官方文档上写的是图像分辨率与累加器分辨率的比值，它把参数空间认为是一个累加器，毕竟里面存储的都是经过的像素点的数量），dp=1，则参数空间与图像像素空间（分辨率）一样大，dp=2，参数空间的分辨率只有像素空间的一半大
    # 4.minDist 圆心之间最小距离，如果距离太小，会产生很多相交的圆，如果距离太大，则会漏掉正确的圆
    # 5.param1 canny检测的双阈值中的高阈值，低阈值是它的一半
    # 6.param2 最小投票数（基于圆心的投票数）
    # 7.minRadius 需要检测圆的最小半径
    # 8.maxRadius 需要检测圆的最大半径
    circles = cv2.HoughCircles(canny, cv2.HOUGH_GRADIENT, 1, 10, param1=128, param2=3, minRadius=1, maxRadius=0)
    circles = np.uint16(np.around(circles))  # 四舍五入，取整
    
    for i in circles[0, :]:
        cv2.circle(image1, (i[0], i[1]), i[2], (0, 0, 255), 2)  # 画圆
        # cv2.circle(image, (i[0], i[1]), 2, (255, 0, 255), 10) # 画圆心
    
    cv2.imshow("HoughCircle", image1)
    cv2.waitKey(0)

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy_size_16_color_FFFFFF_t_70 6]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy_size_16_color_FFFFFF_t_70 7]

import cv2
    import numpy as np
    # 7 后座底部有碰伤
    image = cv2.imread("img/7.bmp")
    image1 = cv2.resize(image, (800, 600))
    image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    cv2.imshow('image1', image1)
    
    # 定义一个圆形
    circle1 = np.zeros(image.shape[0:2], dtype="uint8")
    cv2.circle(circle1, (655, 447), 122, 255, -1)
    
    mask = circle1
    masked = cv2.bitwise_and(image, image, mask=mask)
    # cv2.imshow("masked", masked)
    
    im_o = cv2.resize(masked, (800, 600))
    im_gauss = cv2.GaussianBlur(im_o, (3, 3), 0)
    ret, im = cv2.threshold(im_gauss, 80, 255, 0)
    # cv2.imshow("o", im)
    
    canny = cv2.Canny(im, 100, 200)
    cv2.imshow('Canny', canny)
    
    # 1.image 不用多说，输入矩阵
    # 2.method cv2.HOUGH_GRADIENT 也就是霍夫圆检测，梯度法
    # 3.dp 计数器的分辨率图像像素分辨率与参数空间分辨率的比值（官方文档上写的是图像分辨率与累加器分辨率的比值，它把参数空间认为是一个累加器，毕竟里面存储的都是经过的像素点的数量），dp=1，则参数空间与图像像素空间（分辨率）一样大，dp=2，参数空间的分辨率只有像素空间的一半大
    # 4.minDist 圆心之间最小距离，如果距离太小，会产生很多相交的圆，如果距离太大，则会漏掉正确的圆
    # 5.param1 canny检测的双阈值中的高阈值，低阈值是它的一半
    # 6.param2 最小投票数（基于圆心的投票数）
    # 7.minRadius 需要检测圆的最小半径
    # 8.maxRadius 需要检测圆的最大半径
    circles = cv2.HoughCircles(canny, cv2.HOUGH_GRADIENT, 1, 20, param1=200, param2=6, minRadius=3, maxRadius=10)
    circles = np.uint16(np.around(circles))  # 四舍五入，取整
    
    for i in circles[0, :]:
        cv2.circle(image1, (i[0], i[1]), i[2], (0, 0, 255), 2)  # 画圆
        # cv2.circle(image, (i[0], i[1]), 2, (255, 0, 255), 10) # 画圆心
    
    cv2.imshow("HoughCircle", image1)
    cv2.waitKey(0)

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy_size_16_color_FFFFFF_t_70 8]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy_size_16_color_FFFFFF_t_70 9]

import cv2
    import numpy as np
    # 3 铝垫圈表面有贯穿伤
    image = cv2.imread("img/3.bmp")
    image1 = cv2.resize(image, (800, 600))
    image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    cv2.imshow('image1', image1)
    # cv2.waitKey(0)
    
    # 定义两个圆形
    circle1 = np.zeros(image.shape[0:2], dtype="uint8")
    cv2.circle(circle1, (605, 529), 246, 255, -1)
    circle2 = np.zeros(image.shape[0:2], dtype="uint8")
    # cv2.circle(circle2, (625, 505), 284, 255, -1)
    cv2.circle(circle2, (605, 529), 204, 255, -1)
    
    # 异或运算,通过两个圆建立一个圆环作为掩膜
    bitwiseXor = cv2.bitwise_xor(circle1, circle2)
    mask = bitwiseXor
    cv2.imshow('Mask', mask)
    
    # 将掩膜应用于原图
    masked = cv2.bitwise_and(image, image, mask=mask)
    # cv2.imshow('Mask applied to Image', masked)
    
    im_o = cv2.resize(masked, (800, 600))
    im_gauss = cv2.GaussianBlur(im_o, (3, 3), 0)
    ret, im = cv2.threshold(im_gauss, 180, 255, 0)
    # cv2.imshow("o", im)
    # cv2.waitKey(0)
    
    canny = cv2.Canny(im, 64, 128)
    cv2.imshow('Canny', canny)
    
    # 1.image 不用多说，输入矩阵
    # 2.method cv2.HOUGH_GRADIENT 也就是霍夫圆检测，梯度法
    # 3.dp 计数器的分辨率图像像素分辨率与参数空间分辨率的比值（官方文档上写的是图像分辨率与累加器分辨率的比值，它把参数空间认为是一个累加器，毕竟里面存储的都是经过的像素点的数量），dp=1，则参数空间与图像像素空间（分辨率）一样大，dp=2，参数空间的分辨率只有像素空间的一半大
    # 4.minDist 圆心之间最小距离，如果距离太小，会产生很多相交的圆，如果距离太大，则会漏掉正确的圆
    # 5.param1 canny检测的双阈值中的高阈值，低阈值是它的一半
    # 6.param2 最小投票数（基于圆心的投票数）
    # 7.minRadius 需要检测圆的最小半径
    # 8.maxRadius 需要检测圆的最大半径
    circles = cv2.HoughCircles(canny, cv2.HOUGH_GRADIENT, 1, 10, param1=128, param2=5, minRadius=1, maxRadius=0)
    circles = np.uint16(np.around(circles))  # 四舍五入，取整
    
    for i in circles[0, :]:
        cv2.circle(image1, (i[0], i[1]), i[2], (0, 0, 255), 2)  # 画圆
        # cv2.circle(image, (i[0], i[1]), 2, (255, 0, 255), 10) # 画圆心
    
    cv2.imshow("HoughCircle", image1)
    cv2.waitKey(0)

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy_size_16_color_FFFFFF_t_70 10]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy_size_16_color_FFFFFF_t_70 11]

import cv2
    import numpy as np
    # 5 六面角端面有碰伤
    image = cv2.imread("img/5.bmp")
    image2 = cv2.resize(image, (800, 600))
    image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    
    image = cv2.circle(image, (644, 503), 293, 0, -1)
    image1 = cv2.resize(image, (800, 600))
    # cv2.imshow('image2', image2)
    cv2.imshow('image1', image1)
    # cv2.waitKey(0)
    
    im_gauss = cv2.GaussianBlur(image1, (3, 3), 0)
    ret, im = cv2.threshold(im_gauss, 40, 255, 0)
    cv2.imshow("o", im)
    # canny = cv2.Canny(im, 125, 250)
    canny = cv2.Canny(im, 50, 100)
    cv2.imshow('Canny', canny)
    # cv2.waitKey(0)
    
    # 1.image 不用多说，输入矩阵
    # 2.method cv2.HOUGH_GRADIENT 也就是霍夫圆检测，梯度法
    # 3.dp 计数器的分辨率图像像素分辨率与参数空间分辨率的比值（官方文档上写的是图像分辨率与累加器分辨率的比值，它把参数空间认为是一个累加器，毕竟里面存储的都是经过的像素点的数量），dp=1，则参数空间与图像像素空间（分辨率）一样大，dp=2，参数空间的分辨率只有像素空间的一半大
    # 4.minDist 圆心之间最小距离，如果距离太小，会产生很多相交的圆，如果距离太大，则会漏掉正确的圆
    # 5.param1 canny检测的双阈值中的高阈值，低阈值是它的一半
    # 6.param2 最小投票数（基于圆心的投票数）
    # 7.minRadius 需要检测圆的最小半径
    # 8.maxRadius 需要检测圆的最大半径
    # circles = cv2.HoughCircles(canny, cv2.HOUGH_GRADIENT, 1, 20, param1=250, param2=5, minRadius=4, maxRadius=8)
    circles = cv2.HoughCircles(canny, cv2.HOUGH_GRADIENT, 1, 20, param1=100, param2=7, minRadius=6, maxRadius=1)
    circles = np.uint16(np.around(circles))  # 四舍五入，取整
    
    for i in circles[0, :]:
        cv2.circle(image2, (i[0], i[1]), i[2], (0, 0, 255), 2)  # 画圆
        # cv2.circle(image, (i[0], i[1]), 2, (255, 0, 255), 10) # 画圆心
    
    cv2.imshow("HoughCircle", image2)
    cv2.waitKey(0)

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy_size_16_color_FFFFFF_t_70 12]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy_size_16_color_FFFFFF_t_70 13]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191121223122162.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191121223138474.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20191121224216942.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/2019112122425191.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20191121224328379.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20191125152135776.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20191121224442852.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/2019112122445667.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20191124144941592.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20191124145009631.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy_size_16_color_FFFFFF_t_70 10]: https://img-blog.csdnimg.cn/20191124145041299.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy_size_16_color_FFFFFF_t_70 11]: https://img-blog.csdnimg.cn/20191124145142681.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy_size_16_color_FFFFFF_t_70 12]: https://img-blog.csdnimg.cn/20191125161115259.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy_size_16_color_FFFFFF_t_70 13]: https://img-blog.csdnimg.cn/20191125161136419.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzNTYyOTgy,size_16,color_FFFFFF,t_70