1、阈值分割

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
 
"""
    使用函数cv2.threshold()进行简单的阈值处理
    函数原型为：threshold(src, thresh, maxval, type[, dst]) -> retval, dst
        返回值
            retval：当前用来对像素值进行分类的低阈值,默认情况下和参数thresh相等
            dst：二值化处理后的图像,像素值中只存在0或255
        参数解析：
                src:需要二值化的原图像，必须是灰度图,传入一种彩色图没有意义；
                thresh：用来对像素值进行分类的阈值；
                maxval：就是当像素值高于，有时是小于阈值时应该被赋予的新的像素值；
                type：阈值处理方式，OpenCV提供多种阈值处理方法
                        cv2.THRESH_BINARY：超过阈值部分取maxval（最大值），否则取0
                        cv2.THRESH_BINARY_INV ：THRESH_BINARY的反转
                        cv2.THRESH_TRUNC ：大于阈值部分设为阈值，否则不变
                        cv2.THRESH_TOZERO ：大于阈值部分不改变，否则设为0
                        cv2.THRESH_TOZERO_INV ：THRESH_TOZERO的反转
"""
 
import cv2
 
'1. 初始操作'
src = cv2.imread("Resources/threshold.png", 17)
img = src.copy()
 
'2. 灰度化——cvtColor()参数含义：1）原图  2）目标颜色空间,例如 RGB->HSV'
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
cv2.imshow("gray", gray)
 
'3. 阈值分割（二值化）——threshold()参数含义：1）8位图像（灰度图）  2）比较阈值  3）输出值   4）分割属性'
'返回值函数： ret=比较阈值   thresh=二值化图像（矩阵数组）'
ret, thresh = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
print(ret)
 
'4. 完成显示'
cv2.imshow("src Image", src)
cv2.imshow("thresh Image", thresh)
cv2.waitKey()

2、腐蚀与膨胀，开运算与闭运算

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
 
"""
 腐蚀操作：
    原理：
        比如使用一个3X3的全一矩阵去腐蚀一张灰度图，中心锚点的值就会被替换为对应核中最小的值
        原始数据：
         [[100 127 127 127 127]
         [127 127 127 127 127]
         [127 127 127 127 127]
         [127 127 127 100 127]
         [127 127 127 127 127]]
        ************************************************************
        腐蚀之后的数据
         [[100 100 127 127 127]
         [100 100 127 127 127]
         [127 127 100 100 100]
         [127 127 100 100 100]
         [127 127 100 100 100]]
    erode(src, kernel[, dst[, anchor[, iterations[, borderType[, borderValue]]]]]) -> dst
    参数解析：
        kernel:腐蚀操作的内核。 可以使用函数getStructuringElement()。
        anchor:默认为-1表示内核中心点，省略时为默认值
        iterations:腐蚀次数。省略时为默认值1
        borderType:推断边缘类型，具体参见borderInterpolate函数。默认值为边缘值拷贝
        borderValue:边缘填充值，具体可参见createMorphoogyFilter函数，可省略,默认为0
    dilate(src, kernel[, dst[, anchor[, iterations[, borderType[, borderValue]]]]]) -> dst
    参数解析：
        anchor:默认为Point(-1,-1),内核中心点。省略时为默认值。
        iterations:膨胀次数。省略时为默认值1。
        borderType:推断边缘类型，具体参见borderInterpolate函数。默认为BORDER_DEFAULT, 边缘拷贝
        borderValue:边缘值，具体可参见createMorphoogyFilter函数。可省略。
"""
 
'''
    腐蚀与膨胀
'''
# import cv2
#
# '1. 初始操作'
# src = cv2.imread("Resources/otsu_src.jpg", 17)
#
# '2. 获得形态学变换的【结构元】——ELLIPSE=椭圆形  RECT=矩形   CROSS=交叉形'
# kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
#
# '3. 腐蚀——erode()参数含义：1）原图    2）结构元   iterations=次数'
# er = cv2.erode(src, kernel, iterations=1)
#
# '4. 膨胀——dilate()参数含义：1）原图   3）结构元   iterations=次数'
# di = cv2.dilate(er, kernel, iterations=1)
#
# '5. 完成显示'
# cv2.imshow("src Image", src)
# cv2.imshow("erode Image", er)
# cv2.imshow("dilate Image", di)
# cv2.waitKey(0)
 
######################################################
 
'''
    开操作与闭操作
    开操作 = 腐蚀 + 膨胀       消除部分高亮区域（二值化中的白色区域）
    闭操作 = 膨胀 + 腐蚀       消除高亮区域的内部黑洞（二值化中的黑色区域）
'''
import cv2
 
'1. 初始操作'
src = cv2.imread("Resources/open.png", 0)
img = src.copy()
 
'2. 二值化——threshold'
ret, thresh = cv2.threshold(src, 127, 255, cv2.THRESH_BINARY)
cv2.imshow('thresh', thresh)
 
'3. 获取形态学变换结构元——RECT=矩形'
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (2, 2))
 
'4. 形态学变换函数——morphologyEx()参数含义：1）原图    2）变换属性（开/关操作、礼帽、梯度等）    3）结构元 '
open = cv2.morphologyEx(src, cv2.MORPH_OPEN, kernel, iterations=2)
# op_erode = cv2.erode(src, kernel, iterations=1)
# open = cv2.dilate(op_erode, kernel, iterations=1)
 
'5. 完成显示'
cv2.imshow("Src Image ", img)
cv2.imshow("MORPH_OPEN Image", open)
cv2.waitKey(0)

3、硬币检测与计数的应用实现

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
 
"""
    项目主题：硬币检测和计数的设计与实现
"""
import cv2
import numpy as np
 
 
def stackImages(scale, imgArray):
    """
        将多张图像压入同一个窗口显示
        :param scale:float类型，输出图像显示百分比，控制缩放比例，0.5=图像分辨率缩小一半
        :param imgArray:元组嵌套列表，需要排列的图像矩阵
        :return:输出图像
    """
    rows = len(imgArray)
    cols = len(imgArray[0])
    rowsAvailable = isinstance(imgArray[0], list)
    width = imgArray[0][0].shape[1]
    height = imgArray[0][0].shape[0]
    if rowsAvailable:
        for x in range(0, rows):
            for y in range(0, cols):
                if imgArray[x][y].shape[:2] == imgArray[0][0].shape[:2]:
                    imgArray[x][y] = cv2.resize(imgArray[x][y], (0, 0), None, scale, scale)
                else:
                    imgArray[x][y] = cv2.resize(imgArray[x][y], (imgArray[0][0].shape[1], imgArray[0][0].shape[0]),
                                                None, scale, scale)
                if len(imgArray[x][y].shape) == 2: imgArray[x][y] = cv2.cvtColor(imgArray[x][y], cv2.COLOR_GRAY2BGR)
        imageBlank = np.zeros((height, width, 3), np.uint8)
        hor = [imageBlank] * rows
        hor_con = [imageBlank] * rows
        for x in range(0, rows):
            hor[x] = np.hstack(imgArray[x])
        ver = np.vstack(hor)
    else:
        for x in range(0, rows):
            if imgArray[x].shape[:2] == imgArray[0].shape[:2]:
                imgArray[x] = cv2.resize(imgArray[x], (0, 0), None, scale, scale)
            else:
                imgArray[x] = cv2.resize(imgArray[x], (imgArray[0].shape[1], imgArray[0].shape[0]), None, scale, scale)
            if len(imgArray[x].shape) == 2: imgArray[x] = cv2.cvtColor(imgArray[x], cv2.COLOR_GRAY2BGR)
        hor = np.hstack(imgArray)
        ver = hor
    return ver
 
 
'1. 初始操作'
src = cv2.imread("Resources/coin2.jpg")
img = src.copy()
 
'2. 图像预处理——灰度化'
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
 
'3. 图像预处理——二值化'
ret, thresh = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
 
'4. 图像预处理——消除特有噪声（形态学变换）'
# kernel = np.ones((3, 3), np.uint8)
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
dilate = cv2.morphologyEx(thresh, cv2.MORPH_DILATE, kernel, iterations=2)
opening = cv2.morphologyEx(dilate, cv2.MORPH_CLOSE, kernel, iterations=3)
 
'根据距离变换的性质，经过简单的运算，即可用于细化字符的轮廓和查找物体质心（中心）。'
'5. 寻找前景区域——分离连接物体distanceTranform()参数含义：1）二值图像     2）距离变换类型   3）距离变换的掩膜模板'
# DIST_L2：简单欧几里得距离 Δ = sqrt((x1 - x2)² + (y1 - y2)²)
dist_transform = cv2.distanceTransform(opening, cv2.DIST_L2, 3)
 
'6. 找到未知区域'
ret, sure_fg = cv2.threshold(dist_transform, 0.5 * dist_transform.max(), 255, 0)
print(ret)
sure_fg = np.uint8(sure_fg)
 
'7. 找到硬币中心（轮廓查找）findContours()参数含义：1）8位图像   2）轮廓查找模式    3）查找近似方法'
contours, hierarchy = cv2.findContours(sure_fg, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)[-2:]
 
'8. 绘制硬币中心（轮廓绘制）drawContours()参数含义：1）原图     2）轮廓点坐标   3）轮廓索引    4）线条颜色  5）线条粗细'
cv2.drawContours(img, contours, -1, (0, 0, 255), 3)
 
'9. 完成显示'
'''
    *知识点回顾：
    putText()参数含义：1）图像  2）需显示的文本  3）坐标  4）文本字体  5）文本尺寸百分比   6）文本颜色   7）文本粗细
'''
cv2.putText(img, "count:{}".format(len(contours)), (0, 30), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 255, 0), 3)
cv2.putText(src, "srcImg", (0, 30), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 255, 0), 3)
cv2.putText(gray, "gray", (0, 30), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (255, 255, 255), 3)
cv2.putText(thresh, "thresh", (0, 30), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (255, 255, 255), 3)
cv2.putText(opening, "open", (0, 30), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (255, 255, 255), 3)
cv2.putText(sure_fg, "fg", (0, 30), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (255, 255, 255), 3)
 
imgStack = stackImages(0.7, ([src, gray, thresh], [opening, sure_fg, img]))
cv2.imshow("imgStack", imgStack)
cv2.waitKey(0)

原文链接:https://blog.csdn.net/weixin_45602979/article/details/108831760