cv六

1.图像轮廓发现

# 图像轮廓发现
# 轮廓发现是基于边缘提取的基础寻找对象轮廓的方法
# 所以边缘提取的阈值选定会影响最终轮廓发现结果
# findContour发现轮廓  在发现轮廓的时候，可以直接使用二值化的图像也可以使用边缘提取的图像，用哪个分析实际情景
# drawContours绘制轮廓


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)

    grad_x = cv.Sobel(gray, cv.CV_16SC1, 1, 0)
    grad_y = cv.Sobel(gray, cv.CV_16SC1, 0, 1)

    # edge_output = cv.Canny(grad_x, grad_y, 30, 150)
    edge_output = cv.Canny(gray, 50, 150)
    return edge_output


def contours_demo(image):
    """
    . 轮廓可以简单认为成将连续的点（连着边界）连在一起的曲线，具有相同 的颜色或者灰度。
    轮廓在形状分析和物体的检测和识别中很有用。
    . 为了更加准确，要使用二值化图像。在寻找轮廓之前，要进行阈值化处理或者 Canny 边界检测
    . 查找轮廓的函数会修改原始图像。如果你在找到轮廓之后还想使用原始图像的话，
    你应该将原始图像存储到其他变量中.
    . 在 OpenCV 中，查找轮廓就像在黑色背景中超白色物体。要找的物体应该是白色而背景应该是黑色。
    """
    # dst = cv.GaussianBlur(image, (3, 3), 0)
    # gray = cv.cvtColor(dst, cv.COLOR_BGR2GRAY)
    # ret, binary = cv.threshold(gray, 0, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)
    # cv.imshow("binary image", binary)
    binary = edge_demo(image)
    """
    • 函数 cv2.findContours() 有三个参数, 第一个是输入图像，第二个是轮廓检索模式，第三个是轮廓近似方法。
    • 检索模式：
        • CV_RETR_EXTERNAL - 只提取外层的轮廓  
        • CV_RETR_LIST - 提取所有轮廓，并且放置在 list 中  
        • CV_RETR_CCOMP - 提取所有轮廓，并且将其组织为两层的 hierarchy: 
            顶层为连通域的 外围边界，次层为洞的内层边界。  
        • CV_RETR_TREE - 提取所有轮廓，并且重构嵌套轮廓的全部 hierarchy
    • 逼近方法 (对所有节点, 不包括使用内部逼近的 CV_RETR_RUNS).  点的存贮情况，是不是都被存贮
        • CV_CHAIN_CODE - Freeman 链码的输出轮廓. 其它方法输出多边形(定点序列).  
        • CV_CHAIN_APPROX_NONE - 将所有点由链码形式翻译为点序列形式  
        • CV_CHAIN_APPROX_SIMPLE - 压缩水平、垂直和对角分割，即函数只保留末端的象素 点;  
        • CV_CHAIN_APPROX_TC89_L1,  CV_CHAIN_APPROX_TC89_KCOS - 应用 Teh-Chin 链逼近算法.  
        • CV_LINK_RUNS - 通过连接为 1 的水平碎片使用完全不同的轮廓提取算法。仅有 CV_RETR_LIST 提取模式可以在本方法中应用.  
    • offset:每一个轮廓点的偏移量. 当轮廓是从图像 ROI 中提取出来的时候，使用偏移量有用，因为可以从整个图像上下文来对轮廓做分析. 
    • 返回值有三个，第一个是图像，第二个是轮廓，第三个是（轮廓的）层析结构。
        轮廓（第二个返回值）是一个 Python 列表，其中存储这图像中的所有轮廓。
        每一个轮廓都是一个 Numpy 数组，包含对象边界点（x，y）的坐标。
    """
    contours, hierarchy= cv.findContours(binary, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
    for i, contour in enumerate(contours):
        # 函数 cv2.drawContours() 可以被用来绘制轮廓。它可以根据你提供的边界点绘制任何形状。
        # 它的第一个参数是原始图像，第二个参数是轮廓，一个 Python 列表。
        # 第三个参数是轮廓的索引（在绘制独立轮廓是很有用，当设 置为 -1 时绘制所有轮廓）。
        # 接下来的参数是轮廓的颜色和厚度等。
        cv.drawContours(image, contours, i, (0, 0, 255), 2)  # 2为像素大小，-1时填充轮廓
        print(i)
    cv.imshow("detect contours", image)


def main():
    src = cv.imread("../images/circle.png")
    cv.imshow("demo",src)
    contours_demo(src)
    cv.waitKey(0)  # 等有键输入或者1000ms后自动将窗口消除，0表示只用键输入结束窗口
    cv.destroyAllWindows()  # 关闭所有窗口


if __name__ == '__main__':
    main()

2.对象测量

# 对象测量
# 测量对象的弧长与面积，多边形拟合，几何矩计算


import cv2 as cv
import numpy as np


def measure_object(image):
    gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
    ret, binary = cv.threshold(gray, 0, 255, cv.THRESH_BINARY_INV | cv.THRESH_OTSU)
    print("threshold value: %s"%ret)
    cv.imshow("binary image", binary)

    contours, hierarchy = cv.findContours(binary, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
    for i, contour in enumerate(contours):
        cv.drawContours(image, contours, i, (0, 255, 255), 1)  # 用黄色线条画出轮廓

        area = cv.contourArea(contour)  # 计算轮廓面积
        print("contour area:", area)

        # 轮廓周长,第二参数可以用来指定对象的形状是闭合的（True）,还是打开的（一条曲线）。
        perimeter = cv.arcLength(contour, True)

        print("contour perimeter:", perimeter)

        x, y, w, h = cv.boundingRect(contour)  # 计算轮廓的外接矩形
        cv.rectangle(image, (x, y), (x + w, y + h), (0, 0, 255), 2)

        rate = min(w, h)/max(w, h)  # 计算矩阵宽高比
        print("rectangle rate",rate)

        mm = cv.moments(contour)  # 计算几何矩，函数 cv2.moments() 会将计算得到的几何矩以一个字典的形式返回
        # 计算出对象的重心
        cx = mm['m10']/mm['m00']
        cy = mm['m01']/mm['m00']
        cv.circle(image, (np.int(cx), np.int(cy)), 2, (0, 255, 255), -1)  # 用实心圆画出重心

    cv.imshow("measure_object", image)


def contour_approx(image):
    gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
    ret, binary = cv.threshold(gray, 0, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)
    print("threshold value: %s" % ret)
    cv.imshow("binary image", binary)

    contours, hierarchy = cv.findContours(binary, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
    for i, contour in enumerate(contours):
        cv.drawContours(image, contours, i, (0, 0, 255), 2)  # 用红色线条画出轮廓

        """cv.approxPolyDP(contour, epsilon, True) 参数解释
            .   @param curve Input vector of a 2D point stored in std::vector or Mat
            .   @param approxCurve Result of the approximation. The type should match the type of the input curve.
            .   @param epsilon Parameter specifying the approximation accuracy. This is the maximum distance
            .   between the original curve and its approximation.
            .   @param closed If true, the approximated curve is closed (its first and last vertices are
            .   connected). Otherwise, it is not closed.
        """
        # 将轮廓形状近似到另外一种由更少点组成的轮廓形状，新轮廓的点的数目由我们设定的准确度来决定。
        # 为了帮助理解，假设从一幅图像中查找一个矩形，但是由于图像的种种原因，我们不能得到一个完美的矩形，
        # 而是一个“坏形状”（如下图所示）。
        # 现在你就可以使用这个函数来近似这个形状（）了。
        # 这个函数的第二个参数叫 epsilon，它是从原始轮廓到近似轮廓的最大距离。
        # 它是一个准确度参数。选 择一个好的 epsilon 对于得到满意结果非常重要。

        epsilon = 0.01 * cv.arcLength(contour, True)
        approx = cv.approxPolyDP(contour, epsilon, True)
        if approx.shape[0] > 6:
            cv.drawContours(binary, contour, i, (0, 255, 0), 2)
        if approx.shape[0] == 4:
            cv.drawContours(binary, contour, i, (0, 0, 255), 2)
        if approx.shape[0] == 3:
            cv.drawContours(binary, contour, i, (255, 0, 0), 2)
        cv.drawContours(image, approx, -1, (255, 0, 0), 10)

    cv.imshow("contour_approx", image)


def main():
    # src = cv.imread("../images/handwriting.jpg")
    # cv.imshow("demo",src)
    # measure_object(src)

    img = cv.imread("../images/approximate.png")
    contour_approx(img)
    cv.waitKey(0)  # 等有键输入或者1000ms后自动将窗口消除，0表示只用键输入结束窗口
    cv.destroyAllWindows()  # 关闭所有窗口


if __name__ == '__main__':
    main()

3.膨胀与腐蚀

# 图像形态学两个基本内容：膨胀与腐蚀
# 膨胀：是使用模板下的元素最大值来替换中心像素
# 腐蚀：是使用模板下的元素最小值来替换中心像素


import cv2 as cv
import numpy as np


"""
形态学操作是根据图像形状进行的简单操作。一般情况下对二值化图像进行的操作。
需要输入两个参数，一个是原始图像，第二个被称为结构化元素或 核，它是用来决定操作的性质的。
两个基本的形态学操作是腐蚀和膨胀。他们 的变体构成了开运算，闭运算，梯度等
"""


def erode_demo(image):
    """
    就像土壤侵蚀一样，这个操作会把前景物体的边界腐蚀掉（但是前景仍然 是白色）。
    卷积核沿着图像滑动，如果与卷积核对应的原图像的所有像素值都是 1，
    那么中心元素就保持原来的像素值，否则就变为零。
    这回产生什么影响呢？根据卷积核的大小靠近前景的所有像素都会被腐蚀掉（变为 0），
    所以前景物体会变小，整幅图像的白色区域会减少。
    这对于去除白噪声很有用，也可以用来断开两个连在一块的物体等。
    """
    print(image.shape)
    gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
    ret, binary = cv.threshold(gray, 0, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)
    cv.imshow("binary", binary)

    kernel = cv.getStructuringElement(cv.MORPH_RECT, (5, 5))  # 得到结构元素或说是模板
    dst = cv.erode(binary, kernel=kernel)  # 腐蚀
    cv.imshow("erode_demo", dst)


def dilate_demo(image):
    """
    与腐蚀相反，与卷积核对应的原图像的像素值中只要有一个是 1，中心元 素的像素值就是 1。
    所以这个操作会增加图像中的白色区域（前景）。一般在去 噪声时先用腐蚀再用膨胀。
    因为腐蚀在去掉白噪声的同时，也会使前景对象变 小。所以我们再对他进行膨胀。
    这时噪声已经被去除了，不会再回来了，但是 前景还在并会增加。
    膨胀也可以用来连接两个分开的物体。
    """
    print(image.shape)
    gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
    ret, binary = cv.threshold(gray, 0, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)
    cv.imshow("binary", binary)

    kernel = cv.getStructuringElement(cv.MORPH_RECT, (5, 5))
    dst = cv.dilate(binary, kernel=kernel)  # 膨胀
    cv.imshow("dilate_demo", dst)


def main():
    src = cv.imread("../images/01.jpg")
    # erode_demo(src)
    # dilate_demo(src)

    # 彩色图像腐蚀，膨胀
    img = cv.imread("../images/lena.jpg")
    cv.imshow("img", img)
    kernel = cv.getStructuringElement(cv.MORPH_RECT, (5, 5))
    # dst = cv.dilate(img, kernel=kernel)
    dst = cv.erode(img, kernel=kernel)  # 也可以直接对彩色图像进行膨胀和腐蚀
    cv.imshow("dilate", dst)
    cv.waitKey(0)  # 等有键输入或者1000ms后自动将窗口消除，0表示只用键输入结束窗口
    cv.destroyAllWindows()  # 关闭所有窗口


if __name__ == '__main__':
    main()

4.开操作与闭操作

# 图像形态学重要操作：开操作和闭操作
# 开操作 = 腐蚀+膨胀，可以去除小的干扰块
# 闭操作 = 膨胀+腐蚀，填充闭合区域
# 水平或者垂直线的提取


import cv2 as cv
import numpy as np


"""
开运算:先进性腐蚀再进行膨胀就叫做开运算,它被用来去除噪声。
闭运算:先膨胀再腐蚀。它经常被用来填充前景物体中的小洞，或者前景物体上的小黑点。
这里我们用到的函数是 cv2.morphologyEx()。
开闭操作作用：
1. 去除小的干扰块-开操作
2. 填充闭合区间-闭操作
3. 水平或垂直线提取,调整kernel的row，col值差异。
比如：采用开操作，kernel为(1, 15),提取垂直线，kernel为(15, 1),提取水平线，
"""

"""
其他形态学操作：
顶帽：原图像与开操作之间的差值图像
黑帽：比操作与原图像直接的差值图像
形态学梯度：其实就是一幅图像膨胀与腐蚀的差别。 结果看上去就像前景物体的轮廓
基本梯度：膨胀后图像减去腐蚀后图像得到的差值图像。
内部梯度：用原图减去腐蚀图像得到的差值图像。
外部梯度：膨胀后图像减去原图像得到的差值图像。
"""


def open_demo(image):
    print(image.shape)
    gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
    ret, binary = cv.threshold(gray, 0, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)
    cv.imshow("binary", binary)
    """
    在前面的例子中我们使用Numpy构建了结构化元素，它是正方形的。
    但有时我们需要构建一个椭圆形 / 圆形的核。为了实现这种要求，提供了OpenCV
    函数cv2.getStructuringElement()。你只需要告诉他你需要的核的形状和大小。
    """
    kernel = cv.getStructuringElement(cv.MORPH_RECT, (5, 5))
    dst = cv.morphologyEx(binary, cv.MORPH_OPEN, kernel=kernel)  # MORPH_OPEN 开操作,MORPH_ELLIPSE会保留所有圆的区域
    cv.imshow("open_demo", dst)


def close_demo(image):
    print(image.shape)
    gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
    ret, binary = cv.threshold(gray, 0, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)
    cv.imshow("binary", binary)

    kernel = cv.getStructuringElement(cv.MORPH_RECT, (15, 5))  # 15是水平 5的垂直
    dst = cv.morphologyEx(binary, cv.MORPH_CLOSE, kernel=kernel)  # MORPH_CLOSE 闭操作
    cv.imshow("open_demo", dst)


def other_morphology_demo(image):
    gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
    kernel = cv.getStructuringElement(cv.MORPH_RECT, (5, 5))
    dst = cv.morphologyEx(gray, cv.MORPH_BLACKHAT, kernel=kernel)
    cimg = np.array(gray.shape, np.uint8)
    cimg = 100
    dst = cv.add(dst, cimg)

    cv.imshow("top_hat_demo", dst)


def main():
    src = cv.imread("../images/lena.jpg")
    open_demo(src)
    # close_demo(src)

    # # 彩色图像腐蚀，膨胀
    # img = cv.imread("../images/lena.jpg")
    # cv.imshow("img", img)
    # kernel = cv.getStructuringElement(cv.MORPH_RECT, (5, 5))
    # # dst = cv.dilate(img, kernel=kernel)
    # dst = cv.erode(img, kernel=kernel)
    # cv.imshow("dilate", dst)

    # # tophat, blackhat
    #
    # top_hat_demo(src)

    cv.waitKey(0)  # 等有键输入或者1000ms后自动将窗口消除，0表示只用键输入结束窗口
    cv.destroyAllWindows()  # 关闭所有窗口


if __name__ == '__main__':
    main()

5.其它形态学操作

'''其他形态学操作：
顶帽：原图像与开操作之间的差值图像
黑帽：比操作与原图像直接的差值图像
形态学梯度：其实就是一幅图像膨胀与腐蚀的差别。 结果看上去就像前景物体的轮廓
基本梯度：膨胀后图像减去腐蚀后图像得到的差值图像。
内部梯度：用原图减去腐蚀图像得到的差值图像。
外部梯度：膨胀后图像减去原图像得到的差值图像。'''

import cv2 as cv
import numpy as np


def hat_fray_demo(image):  # 对灰度图像
    gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
    kernel = cv.getStructuringElement(cv.MORPH_RECT, (5, 5))
    dst1 = cv.morphologyEx(gray, cv.MORPH_TOPHAT, kernel=kernel)  # MORPH_TOPHAT顶帽
    dst2 = cv.morphologyEx(gray, cv.MORPH_BLACKHAT, kernel=kernel)  # BLACKHAT黑帽
    cimage = np.array(gray.shape, np.uint8)
    cimage = 100
    cv.add(dst1, cimage)  # 每个值加100
    cv.add(dst2, cimage)  # 每个值加100
    cv.imshow('topHat', dst1)
    cv.imshow('topHat', dst2)


def hat_binary_demo(image):  # 对二值图像
    gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
    ret, binary = cv.threshold(gray, 0, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)
    kernel = cv.getStructuringElement(cv.MORPH_RECT, (5, 5))
    dst1 = cv.morphologyEx(binary, cv.MORPH_TOPHAT, kernel=kernel)  # MORPH_TOPHAT顶帽
    dst2 = cv.morphologyEx(binary, cv.MORPH_BLACKHAT, kernel=kernel)  # BLACKHAT黑帽
    dst3 = cv.morphologyEx(binary, cv.MORPH_GRADIENT, kernel=kernel)  # GRADIENT基本梯度
    cv.imshow('topHat', dst1)
    cv.imshow('topHat', dst2)


def gradient_demo(image):  # 内梯度和外梯度
    kernel = cv.getStructuringElement(cv.MORPH_RECT, (3, 3))
    dm = cv.dilate(image, kernel)
    em = cv.erode(image, kernel)
    dst1 =cv.subtract(image, em)  # 内部梯度
    dst2 =cv.subtract(dm, image)  # 外部梯度
    cv.imshow('topHat', dst1)
    cv.imshow('topHat', dst2)