精华内容
下载资源
问答
  • 2022-03-20 11:24:12
    class Cascade
    {
    public:
        Cascade()
        {
    
        }
        bool load_cascade()
        {
            return cascade.load(m_cascadexml);
        }
        void setCascade(string cascade)
        {
            m_cascadexml=cascade;
        }
        string getCascade()
        {
            return m_cascadexml;
        }
        void detect(cv::Mat &frame)
        {
            std::vector<Rect> obj;
            Mat frame_gray;
            cvtColor(frame, frame_gray, COLOR_BGR2GRAY);
            equalizeHist(frame_gray, frame_gray);
            //-- Detect objects
            cascade.detectMultiScale(frame_gray, obj, 1.1, 3, CV_HAAR_DO_ROUGH_SEARCH, Size(70, 70),Size(100,100));
            for (size_t i = 0; i < obj.size(); i++)
            {
                rectangle(frame, obj[i],Scalar(255,0,0),2,8,0);
            }
        }
        cv::Mat getdetectFrame()
        {
            return m_frame;
        }
    private:
        CascadeClassifier cascade;
        std::string m_cascadexml="";
        cv::Mat m_frame;
    };
    
    
    更多相关内容
  • 可以识别水果,物体
  • 内含代码可以检测运动物体,采用高斯混合模型算法提取前景
  • 使用OpenCV进行物体检测的实验 BlobTrack1.py进行简单的运动跟踪(blob速度和距离移动)。 示例视频非常简单,它实际上并不匹配一帧到下一帧的斑点,但是当帧中只有一个运动对象时,它仍然可以工作。 比较位置,大小...
  • 主要为大家详细介绍了基于OpenCv的运动物体检测算法,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 交互界面达到的效果是,通过点击画面上的按钮来控制是否要显示相应物体的检测结果,即是否把... 这里放置了两个版本,物体检测代码是相同的,不同的是交互性的设计,2.0调用的是现成的button函数,使用起来更方便些。
  • 用python和OpenCV进行动态物体检测 此程序将摄像头录制的视频转化为灰度视频,在将压缩后灰度明显不同的区域用矩形框选起来,得到侦测结果。 实现效果 程序编写 初始化,测试摄像头 读取、转换视频 对比转换后摄像头...
  • 用于寻找物体的轮廓。 img,countours,hierarchy = cv2.findContours(image, mode, method) 参数解释: image:寻找轮廓的图像 mode:表示轮廓的检索模式 method:轮廓的近视办法 mode 说明 cv2.RETR_...

    一、cv2.findContours()

    用于寻找物体的轮廓。

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

    参数解释:

    • image:寻找轮廓的图像
    • mode:表示轮廓的检索模式
    • method:轮廓的近视办法
    mode说明
    cv2.RETR_EXTERNAL表示只检测外轮廓
    cv2.RETR_LIST检测所有的轮廓,包括内围、外围轮廓,但是检测到的轮廓不建立等级关系
    cv2.RETR_CCOMP检测所有的轮廓,但所有轮廓只建立两个等级关系
    cv2.RETR_TREE检测所有轮廓,所有轮廓建立一个等级树结构
    method说明
    cv2.CHAIN_APPROX_NONE保存物体边界上所有连续的轮廓点到contours向量内
    cv2.CHAIN_APPROX_SIMPLE仅保存轮廓的拐点信息,把所有轮廓拐点处的点保存入contour向量内

    返回值:

    • 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自带的模型实现对视频流中的行人检测,只需打开一个新...

    您是否知道 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前:

    image-20211220070648651

    nms后:

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

    展开全文
  • opencv学习】【运动物体检测

    千次阅读 2022-02-14 22:28:32
    今天学习运动物体检测 一:帧差法 捕获摄像头的运动的手 import cv2 import numpy as np # 如果我们想捕获一些运动的物体,每一帧图像中,不动的部分称之为背景,运动的物体称之为前景 # 假如我们的视频捕捉窗口是...

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

    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()
    

    效果如下:
    请添加图片描述
    请添加图片描述
    请添加图片描述

    展开全文
  • 使用 OpenCV 进行 YOLO 对象检测 本文将教你如何使用YOLOV3对象检测器、OpenCV和Python实现对图像和视频流的检测。用到的文件有yolov3.weights、yolov3.cfg、coco.names,这三个文件的github链接如下: GitHub - ...
  • opencv物体识别-识别水果

    千次阅读 多人点赞 2021-11-26 20:39:39
    玩一玩用opencv做一些简单的物体识别 1.思路讲解 我们基于简单的opencv的阈值分割,通过这个阈值分割,我们能把我们需要识别的物体在二值图里面变成白色,其余的变成黑色。然后对我们分割出来的物体部分提取轮廓,算...
  • 基于opencv的运动物体检测方法总结

    千次阅读 2020-04-14 19:15:14
    今天朋友问我要一个车上充满点点的图片,然后我第一时间想到了光流法,然后想到了之前总结的运动物体检测的几个方法,还在有道云笔记里面,所以打算搬迁过来。 帧间差分法 定义:利用相邻的两帧或者三帧图像,利用...
  • 主要介绍了使用Python和OpenCV检测图像中的物体并将物体裁剪下来,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 如何使用OpenCV物体进行搜索检测与识别

    万次阅读 多人点赞 2019-09-20 10:33:33
    物体检测与物体识别 对象识别算法识别图像中存在哪些对象。它将整个图像作为输入,并输出该图像中存在的对象的类标签和类概率。例如,类标签可以是“狗”,相关的类概率可以是97%。 另一方面,对象检测算法不仅...
  • OpenCV 物体跟踪

    千次阅读 2020-09-07 00:09:02
    明确任务 利用opencv知识,通过摄像头录像,实时提取带有某个特定颜色的物体,从而实现物体跟踪。 2.需要用到的函数 cv2.VideoCapture(0) 这个函数用来捕获视频,VideoCapture()中参数是0,表示打开笔记本的内置...
  • opencv 导入dnn模型进行物体检测,通过画面上的按钮控制是否将物体轮廓框出,完整工程在文末
  • opencv运动物体检测

    2012-03-28 13:32:58
    opencv运动物体检测,检测视频中的运动物体,并分离出前景背景
  • 基于OpenCV实战:动态物体检测

    千次阅读 2021-04-26 00:53:34
    点击上方“小白学视觉”,选择加"星标"或“置顶”重磅干货,第一时间送达 最近,闭路电视安全系统运行着多种算法来确保安全,例如面部识别,物体检测,盗窃检测,火灾警报等。我们...
  • OpenCV中最基础的就是对于各种图像的处理,今天就检测物体总结几个常用的方法。 (1)背景建模法  1. Single Gaussian (单高斯模型)  Real-time tracking of the human body  2. 混合高斯模型(Mixture of ...
  • OpenCV.物体识别

    2021-03-09 15:52:44
    1、度娘:“OpenCV 物体识别”ZC:主看这个,讲的比较细致,操作一般都是使用的 OpenCV里面的exe,一些代码是 java的 可以搞定,最后一段测试代码 是Python 但是比较短 应该可以转成C++的来测试。ZC:照着做了,还需...
  • OpenCV移动物体检测

    2021-04-05 00:08:57
    25, 255, cv2.THRESH_BINARY)[1] #膨胀图像 thresh = cv2.dilate(thresh, None, iterations=2) # findContours检测物体轮廓(寻找轮廓的图像,轮廓的检索模式,轮廓的近似办法) contours, hierarchy = cv2....
  • 【实例简介】利用VS2010和Opencv实现物体的追踪【实例截图】【核心代码】boxLocate└── boxLocate├── boxLocate│ ├── box1.jpg│ ├── box2.jpg│ ├── box3.jpg│ ├── box4.jpg│ ├── box5.jpg...
  • OpenCV训练自己的物体检测分类器步骤

    千次阅读 多人点赞 2021-10-06 20:07:41
    环境:python3.7 OpenCV3.4.3.18 工具: opencv_annotation.exe opencv_createsamples.exe opencv_traincascade.exe
  • 2.使用opencv中createBackgroundSubtractorMOG2()运动物体背景分割,及后续目标检测 3.代码中实现了对车辆的检测和跟踪 4.代码计算量小,可实现实时跟踪 5.可对感兴趣区域(ROI)进行单独检测和跟踪 6.代码关键步骤...
  • 检测阶段在一般OpenCV文档的objdetect模块的文档中描述。 文档提供了有关级联分类器的一些基本信息。 当前指南描述了如何训练级联分类器:准备训练数据和运行训练应用程序。 OpenCV中有两个用于训练级联分类器的...
  • OpenCV物体颜色检测(Python)

    千次阅读 2021-02-04 16:13:00
    最近工作又来新活了,船舶颜色检测。开始接到这个活还是有点懵,后面慢慢的感觉来了!!! 一、前期调查 因为本项目涉及到颜色判断与分类,笔者一开始就想到的就是每种颜色的范围划分是什么,刚开始想的是否能够...
  • 简单几行就可以实现对动态物体的追踪,足见opencv在图像处理上的强大。 python代码: import cv2 import numpy as np camera=cv2.VideoCapture(0) firstframe=None while True: ret,frame = camera.read() if not...
  • 主要为大家详细介绍了使用OpenCV检测图像中的矩形,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,809
精华内容 7,923
关键字:

opencv物体检测