一、cv2.findContours()

用于寻找物体的轮廓。

contours,hierarchy = cv2.findContours(image, mode, method)

参数解释：

• image：寻找轮廓的图像
• mode：表示轮廓的检索模式
• method：轮廓的近视办法

返回值：

• contours：向量内每个元素保存了一组由连续的Point点构成的点的集合的向量，每一组Point点集就是一个轮廓。有多少；轮廓，向量contours就有多少元素。
• hierarchy：向量内每一个元素包含了4个int型变量：[后一个轮廓，前一个轮廓，父轮廓，内嵌轮廓]

二、cv2.drawContours()

用于绘制物体的轮廓。

cv2.drawContours(image,contours,contourldx,color,thickness)

参数解释

• image：需要绘制的图像
• contours：探测的轮廓
• contourldx：表明要绘制轮廓的参数。如果为负，则绘制所有轮廓
• color：绘制轮廓颜色
• thickness：轮廓线粗细

三、实例

import cv2
import numpy as np

## 创建一个300*300图像
img = np.zeros((450,450),dtype = np.uint8)
img_ori = cv2.bitwise_not(img)
cv2.rectangle(img_ori,(20,100),(100,250),0,6)
cv2.circle(img_ori,(280,170),150,0,6)
cv2.circle(img_ori,(280,290),150,0,6)

def draw_contours(contour,ldx,color,thickness):
    img = np.ones((450,450),dtype = np.uint8)*255
    cv2.drawContours(img,contour,ldx,color,thickness)
    return img

## 1.只检测外层轮廓
contour1,hierarchy1 = cv2.findContours(img_ori,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
img_res1 = draw_contours(contour1,-1,0,3)
print("只检测外层轮廓：",hierarchy1)

## 2.不建立等级关系的所有轮廓
contour2,hierarchy2 = cv2.findContours(img_ori,cv2.RETR_LIST,cv2.CHAIN_APPROX_SIMPLE)
img_res2 = draw_contours(contour2,-1,0,3)
print("不建立等级关系的所有轮廓：\n",hierarchy2)

## 3.只建立两个等级关系的所有轮廓
contour3,hierarchy3 = cv2.findContours(img_ori,cv2.RETR_CCOMP,cv2.CHAIN_APPROX_SIMPLE)
img_res3 = draw_contours(contour3,-1,0,3)
print("只建立两个等级关系的所有轮廓：\n",hierarchy3)

## 4.建立一个等级树结构的所有轮廓
contour4,hierarchy4 = cv2.findContours(img_ori,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
img_res4 = draw_contours(contour4,-1,0,3)
print("建立一个等级树结构的所有轮廓：\n",hierarchy4)

cv2.imshow('origin',img_ori)
cv2.imshow('res1', img_res1)
cv2.imshow('res2', img_res2)
cv2.imshow('res3', img_res3)
cv2.imshow('res4', img_res4)
cv2.waitKey(0)
cv2.destroyAllWindows()

1.只检测外层轮廓

当只检测外层轮廓时，向量只有一个，即图片的外框，所以无前后轮廓，无等级关系，故hierarchy的四个参数都为-1。

2.不建立等级关系的所有轮廓

由于不建立等级，第三、第四个参数全为-1，所有轮廓一共有7个，以第一个[1 -1 -1 -1]为例说明，第一个的后一个轮廓索引编号（从0开始）为1，无前一个轮廓，故第一个参数为1，第二个参数为-1。

3.只建立两个等级关系的所有轮廓

只建立两个等级关系的所有轮廓指所有轮廓只建立两个等级关系，外围为顶层，若外围内的内围轮廓还包含了其他的轮廓信息，则内围内的所有轮廓均归属于顶层。下面以颜色表示轮廓：黑色⊆紫色⊆红色。所以顶层的元素有4个黑色轮廓和1个红色轮廓，而红色轮廓有两个内嵌轮廓（紫色）。

4.建立一个等级树结构的所有轮廓

您是否知道 OpenCV 具有执行行人检测的内置方法？

OpenCV 附带一个预训练的 HOG + 线性 SVM 模型，可用于在图像和视频流中执行行人检测。

今天我们使用Opencv自带的模型实现对视频流中的行人检测，只需打开一个新文件，将其命名为 detect.py ，然后加入代码：

# import the necessary packages
from __future__ import print_function
import numpy as np
import argparse
import cv2
import os

导入需要的包，然后定义项目需要的方法。

def nms(boxes, probs=None, overlapThresh=0.3):
    # if there are no boxes, return an empty list
    if len(boxes) == 0:
        return []

    # if the bounding boxes are integers, convert them to floats -- this
    # is important since we'll be doing a bunch of divisions
    if boxes.dtype.kind == "i":
        boxes = boxes.astype("float")

    # initialize the list of picked indexes
    pick = []

    # grab the coordinates of the bounding boxes
    x1 = boxes[:, 0]
    y1 = boxes[:, 1]
    x2 = boxes[:, 2]
    y2 = boxes[:, 3]

    # compute the area of the bounding boxes and grab the indexes to sort
    # (in the case that no probabilities are provided, simply sort on the
    # bottom-left y-coordinate)
    area = (x2 - x1 + 1) * (y2 - y1 + 1)
    idxs = y2

    # if probabilities are provided, sort on them instead
    if probs is not None:
        idxs = probs

    # sort the indexes
    idxs = np.argsort(idxs)

    # keep looping while some indexes still remain in the indexes list
    while len(idxs) > 0:
        # grab the last index in the indexes list and add the index value
        # to the list of picked indexes
        last = len(idxs) - 1
        i = idxs[last]
        pick.append(i)

        # find the largest (x, y) coordinates for the start of the bounding
        # box and the smallest (x, y) coordinates for the end of the bounding
        # box
        xx1 = np.maximum(x1[i], x1[idxs[:last]])
        yy1 = np.maximum(y1[i], y1[idxs[:last]])
        xx2 = np.minimum(x2[i], x2[idxs[:last]])
        yy2 = np.minimum(y2[i], y2[idxs[:last]])

        # compute the width and height of the bounding box
        w = np.maximum(0, xx2 - xx1 + 1)
        h = np.maximum(0, yy2 - yy1 + 1)

        # compute the ratio of overlap
        overlap = (w * h) / area[idxs[:last]]

        # delete all indexes from the index list that have overlap greater
        # than the provided overlap threshold
        idxs = np.delete(idxs, np.concatenate(([last],
                                               np.where(overlap > overlapThresh)[0])))

    # return only the bounding boxes that were picked
    return boxes[pick].astype("int")
image_types = (".jpg", ".jpeg", ".png", ".bmp", ".tif", ".tiff")
def list_images(basePath, contains=None):
    # return the set of files that are valid
    return list_files(basePath, validExts=image_types, contains=contains)


def list_files(basePath, validExts=None, contains=None):
    # loop over the directory structure
    for (rootDir, dirNames, filenames) in os.walk(basePath):
        # loop over the filenames in the current directory
        for filename in filenames:
            # if the contains string is not none and the filename does not contain
            # the supplied string, then ignore the file
            if contains is not None and filename.find(contains) == -1:
                continue
            # determine the file extension of the current file
            ext = filename[filename.rfind("."):].lower()
            # check to see if the file is an image and should be processed
            if validExts is None or ext.endswith(validExts):
                # construct the path to the image and yield it
                imagePath = os.path.join(rootDir, filename)
                yield imagePath
def resize(image, width=None, height=None, inter=cv2.INTER_AREA):
    dim = None
    (h, w) = image.shape[:2]
    # 如果高和宽为None则直接返回
    if width is None and height is None:
        return image
    # 检查宽是否是None
    if width is None:
        # 计算高度的比例并并按照比例计算宽度
        r = height / float(h)
        dim = (int(w * r), height)
    # 高为None
    else:
        # 计算宽度比例，并计算高度
        r = width / float(w)
        dim = (width, int(h * r))
    resized = cv2.resize(image, dim, interpolation=inter)
    # return the resized image
    return resized

nms函数：非极大值抑制。

list_images：读取图片。

resize：等比例改变大小。

# construct the argument parse and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-i", "--images", default='test1', help="path to images directory")
args = vars(ap.parse_args())
# 初始化 HOG 描述符/人物检测器
hog = cv2.HOGDescriptor()
hog.setSVMDetector(cv2.HOGDescriptor_getDefaultPeopleDetector())

定义输入图片的文件夹路径。

初始化HOG检测器。

# loop over the image paths
for imagePath in list_images(args["images"]):
    # 加载图像并调整其大小以
    # （1）减少检测时间
    # （2）提高检测精度
    image = cv2.imread(imagePath)
    image = resize(image, width=min(400, image.shape[1]))
    orig = image.copy()
    print(image)
    # detect people in the image
    (rects, weights) = hog.detectMultiScale(image, winStride=(4, 4),
                                            padding=(8, 8), scale=1.05)
    # draw the original bounding boxes
    print(rects)
    for (x, y, w, h) in rects:
        cv2.rectangle(orig, (x, y), (x + w, y + h), (0, 0, 255), 2)
    # 使用相当大的重叠阈值对边界框应用非极大值抑制，以尝试保持仍然是人的重叠框
    rects = np.array([[x, y, x + w, y + h] for (x, y, w, h) in rects])
    pick = nms(rects, probs=None, overlapThresh=0.65)
    # draw the final bounding boxes
    for (xA, yA, xB, yB) in pick:
        cv2.rectangle(image, (xA, yA), (xB, yB), (0, 255, 0), 2)
    # show some information on the number of bounding boxes
    filename = imagePath[imagePath.rfind("/") + 1:]
    print("[INFO] {}: {} original boxes, {} after suppression".format(
        filename, len(rects), len(pick)))
    # show the output images
    cv2.imshow("Before NMS", orig)
    cv2.imshow("After NMS", image)
    cv2.waitKey(0)

遍历 --images 目录中的图像。

然后，将图像调整为最大宽度为 400 像素。尝试减少图像尺寸的原因有两个：

• 减小图像大小可确保需要评估图像金字塔中的滑动窗口更少（即从线性 SVM 中提取 HOG 特征，然后将其传递给线性 SVM），从而减少检测时间（并提高整体检测吞吐量）。
• 调整我们的图像大小也提高了我们行人检测的整体准确性（即更少的误报）。

通过调用 hog 描述符的 detectMultiScale 方法，检测图像中的行人。 detectMultiScale 方法构造了一个比例为1.05 的图像金字塔，滑动窗口步长分别为x 和y 方向的(4, 4) 个像素。

滑动窗口的大小固定为 64 x 128 像素，正如开创性的 Dalal 和 Triggs 论文《用于人体检测的定向梯度直方图》所建议的那样。 detectMultiScale 函数返回 rects 的 2 元组，或图像中每个人的边界框 (x, y) 坐标和 weights ，SVM 为每次检测返回的置信度值。

较大的尺度大小将评估图像金字塔中的较少层，这可以使算法运行得更快。然而，规模太大（即图像金字塔中的层数较少）会导致行人无法被检测到。同样，过小的比例尺会显着增加需要评估的图像金字塔层的数量。这不仅会造成计算上的浪费，还会显着增加行人检测器检测到的误报数量。也就是说，在执行行人检测时，比例是要调整的最重要的参数之一。我将在以后的博客文章中对每个参数进行更彻底的审查以检测到多尺度。

获取初始边界框并将它们绘制在图像上。

但是，对于某些图像，您会注意到每个人检测到多个重叠的边界框。

在这种情况下，我们有两个选择。我们可以检测一个边界框是否完全包含在另一个边界框内。或者我们可以应用非最大值抑制并抑制与重要阈值重叠的边界框。

应用非极大值抑制后，得到最终的边界框，然后输出图像。

运行结果：

nms前：

nms后：

结论：
相比现在的深度学习方法，机器学习的精度低了很多。
完整代码：
https://download.csdn.net/download/hhhhhhhhhhwwwwwwwwww/67160136

今天学习运动物体检测
一：帧差法
捕获摄像头的运动的手

import cv2
import numpy as np

# 如果我们想捕获一些运动的物体，每一帧图像中，不动的部分称之为背景，运动的物体称之为前景
# 假如我们的视频捕捉窗口是不动的，比如摄像头放着不动，保证了背景是基本不发生变化的，但是我们怎么捕获前景和背景啊？
# 第一部分: 帧差法
# 通过前后两帧的差值来捕捉运动的物体（一般用时间t的帧减去时间t-1的帧），超过某个阈值，则判断是前景，否则是背景
# 这个方法很简单，但是会带来巨大的噪声（微微震动，零星点）和空洞（运动物体非边缘部分也被判断成了背景）

cap = cv2.VideoCapture(0)  # 其参数0表示第一个摄像头，一般就是笔记本的内建摄像头。
# cap = cv2.VideoCapture('images/kk 2022-01-23 18-21-21.mp4')  # 来自vedio视频的

# 获取第一帧
ret, frame = cap.read()
frame_prev = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)  # 将彩色图像转成灰度图

kernel1 = np.ones((5, 5), np.uint8)  # 为了开运算使用
while (1):
    # 获取每一帧
    ret, frame = cap.read()
    if frame is None:
        print("camera is over...")
        break

    frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)  # 将彩色图像转成灰度图
    diff = frame - frame_prev  # 肯定有一些是负数，全是灰度值的相减

    diff_abs = cv2.convertScaleAbs(diff)  # 取绝对值，保留我们的差异值

    _, thresh1 = cv2.threshold(diff_abs, 100, 255, cv2.THRESH_BINARY)  # 二值化处理

    MORPH_OPEN_1 = cv2.morphologyEx(thresh1, cv2.MORPH_OPEN, kernel1)  # 开运算，去除噪声和毛刺
    # erosion_it2r_1 = cv2.dilate(MORPH_OPEN_1, kernel1, iterations=2)  # 膨胀操作

    # cv2.imshow("capture", thresh1)  # 展示该图像
    cv2.imshow("capture", MORPH_OPEN_1)  # 展示该图像

    frame_prev = frame  # 更新前一帧

    # 进行等待或者退出判断
    if cv2.waitKey(1) & 0xFF == 27:
        break
cap.release()
cv2.destroyAllWindows()

捕捉视频的帧，捕获坤坤的打篮球和跳舞

import cv2
import numpy as np

# 如果我们想捕获一些运动的物体，每一帧图像中，不动的部分称之为背景，运动的物体称之为前景
# 假如我们的视频捕捉窗口是不动的，比如摄像头放着不动，保证了背景是基本不发生变化的，但是我们怎么捕获前景和背景啊？
# 第一部分: 帧差法
# 通过前后两帧的差值来捕捉运动的物体（一般用时间t的帧减去时间t-1的帧），超过某个阈值，则判断是前景，否则是背景
# 这个方法很简单，但是会带来巨大的噪声（微微震动，零星点）和空洞（运动物体非边缘部分也被判断成了背景）

cap = cv2.VideoCapture('images/kk 2022-01-23 18-21-21.mp4')  # 来自vedio视频的

# 获取第一帧
ret, frame = cap.read()
frame_prev = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)  # 将彩色图像转成灰度图

# kernel1 = np.ones((5, 5), np.uint8)  # 为了开运算使用
while (1):
    # 获取每一帧
    ret, frame = cap.read()
    if frame is None:
        print("camera is over...")
        break

    frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)  # 将彩色图像转成灰度图
    diff = frame - frame_prev  # 肯定有一些是负数，全是灰度值的相减

    diff_abs = cv2.convertScaleAbs(diff)  # 取绝对值，保留我们的差异值

    _, thresh1 = cv2.threshold(diff_abs, 100, 255, cv2.THRESH_BINARY)  # 二值化处理

    # MORPH_OPEN_1 = cv2.morphologyEx(thresh1, cv2.MORPH_OPEN, kernel1)  # 开运算，去除噪声和毛刺
    # erosion_it2r_1 = cv2.dilate(MORPH_OPEN_1, kernel1, iterations=2)  # 膨胀操作

    cv2.imshow("capture", diff_abs)  # 展示该图像
    # cv2.imshow("capture", thresh1)  # 展示该图像
    # cv2.imshow("capture", MORPH_OPEN_1)  # 展示该图像

    frame_prev = frame  # 更新前一帧

    # 进行等待或者退出判断
    if cv2.waitKey(24) & 0xFF == 27:
        break
cap.release()
cv2.destroyAllWindows()

效果如下：

总体而言，帧差法的效果真的是不忍直视。

二：高斯混合模型（GMM）
在进行前景检测前，先进行背景的学习和训练，对图像的每一个背景采用一个GMM进行模拟，每个背景的混合高斯模型是可以训练的，是自适应的。在测试阶段，对新来的像素进行GMM检测，如果像素值匹配某个高斯模型（进行概率值计算，看看和哪个高斯模型接近，或者看看和均值的偏离程度），则认为是背景，否则认为是前景（剧烈变化的像素，属于异常而原理GMM模型）。由于整个过程中GMM模型在不断的更新学习，多以对动态背景有一定的鲁棒性。

我们的视频中的每一帧的像素点不可能是一成不变的（理想很丰满），总会有空气密度导致的变化，吹一吹风，或者摄像头的微微抖动。但是正常情况下，我们都认为背景中的像素点都是满足一个高斯分布，在一定的概率下抖动是正常的。

我们的背景实际上也应当是多个高斯分布的混合分布，且每个高斯模型也是可以带权重的。因为背景有蓝天，建筑，树木花草，马路等。这些都是一些分布。

至于GMM和EM算法的内容和关系，我们在之前学习过，这里就不再讲述了。EM算法是求解GMM的一个方法。

运用在图像中的话，是怎么做的呢？步骤如下：
1：首先初始化每个高斯模型矩阵参数，初始的方差都是假设的（比如设置为5）。
2：先给T帧图像进行训练GMM，来了第一个像素后把他当成第一个高斯分布，比如作为均值。
3：后面再来一个像素，和当前的高斯分布作对比，如果该像素值和与当前的高斯模型的均值的差值在3倍的方差以内，就认为是属于该高斯分布，并对高斯分布参数进行更新。
4：如果该像素不满足该高斯分布。则用这个新的像素建立一个新的高斯分布（用它做均值，假设一个方差（比如设置为5））。但是一个像素位置不要太多个高斯分布，太多了会造成计算量巨大。3~5个基本够了。

GMM测试步骤：
对于新来的像素值，和GMM的的多个高斯分布的均值分别作比较，其差值在2倍的方差之内，则认为是背景，否则是前景。前景像素点设置为255，背景像素点设置为0，行成了一个二值图像。

import cv2
import numpy as np

cap = cv2.VideoCapture('images/kk 2022-01-23 18-21-21.mp4')  # 来自vedio视频的

kernel1 = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
mog = cv2.createBackgroundSubtractorMOG2()  # 创建混合高斯模型来用于北京建模

while (1):
    # 获取每一帧
    ret, frame = cap.read()
    if frame is None:
        print("camera is over...")
        break

    fmask = mog.apply(frame)  # 判断哪些是前景和背景

    MORPH_OPEN_1 = cv2.morphologyEx(fmask, cv2.MORPH_OPEN, kernel1)  # 开运算，去除噪声和毛刺

    contours, _ = cv2.findContours(fmask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)  # 只检测外边框

    for cont in contours:
        # 计算各个轮廓的面积
        len = cv2.arcLength(cont, True)
        if len > 300:  # 去除一些小的噪声点
            # 找到一个轮廓
            x,y,w,h = cv2.boundingRect(cont)
            # 画出这个矩形
            cv2.rectangle(frame, (x,y), (x+w, y+h), color=(0,255,0), thickness=3)

    # 画出所有的轮廓
    cv2.imshow('frame', frame)
    cv2.imshow('fmask', fmask)

    # 进行等待或者退出判断
    if cv2.waitKey(24) & 0xFF == 27:
        break

cap.release()
cv2.destroyAllWindows()

效果如下：

三：KNN
也是根据每个像素点的历史信息进行统计额比较，来判断新来的像素值是不是背景。具体的原理后面补充。

import cv2
import numpy as np

cap = cv2.VideoCapture('images/kk 2022-01-23 18-21-21.mp4')  # 来自vedio视频的

kernel1 = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
knn = cv2.createBackgroundSubtractorKNN()  # 创建KNN模型

while (1):
    # 获取每一帧
    ret, frame = cap.read()
    if frame is None:
        print("camera is over...")
        break

    fmask = knn.apply(frame)  # 判断哪些是前景和背景

    MORPH_OPEN_1 = cv2.morphologyEx(fmask, cv2.MORPH_OPEN, kernel1)  # 开运算，去除噪声和毛刺

    contours, _ = cv2.findContours(fmask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)  # 只检测外边框

    for cont in contours:
        # 计算各个轮廓的面积
        len = cv2.arcLength(cont, True)
        if len > 200:  # 去除一些小的噪声点
            # 找到一个轮廓
            x,y,w,h = cv2.boundingRect(cont)
            # 画出这个矩形
            cv2.rectangle(frame, (x,y), (x+w, y+h), color=(0,255,0), thickness=3)

    # 画出所有的轮廓
    cv2.imshow('frame', frame)
    cv2.imshow('fmask', fmask)

    # 进行等待或者退出判断
    if cv2.waitKey(24) & 0xFF == 27:
        break

cap.release()
cv2.destroyAllWindows()

效果如下：