精华内容
下载资源
问答
  • 物体追踪
    2022-05-01 21:24:30

    不同与之前的背景分割的追踪方法,MeanShift从背景以及前景物体两方面进行建模。

    在程序一开始设定感兴趣的区域,并初始化滑动窗口用于后续的绘制。利用计算的直方图进行反映射,越亮的区域表示感兴趣的区域(即希望追踪的区域)

    程序如下,需要修改你感兴趣的区域的图像的大致位置。

    其余函数各参数的含义均已经注释。

    # 在之前的背景差分检测物体中,只是对背景建立某种模型,一旦摄像头本身发生移动,整个背景模型都会过时
    # 我们希望区分所关注的物体与其他物体,即使路径上存在交叉
    # 实质上是一种聚类算法,通过不断迭代,计算质心,移动矩形,最后实现收敛
    import cv2
    
    # 打开摄像头
    cap = cv2.VideoCapture(0)
    success, frame = cap.read()
    
    # 丢弃9帧,让相机有足够时间调整
    for i in range(10):
        success, frame = cap.read()
        print(frame)
        if not success:
            exit(1)
    
    # 初始化定义一个滑动窗口,这个没有什么规定,看你想要追踪物体的大小而定
    # 通过shape获取图像的长度与宽度
    frame_h, frame_w = frame.shape[:2]
    w = frame_w // 4
    h = frame_h // 4
    x = frame_w // 2 - w // 2
    y = frame_h // 2 - h // 2
    track_window = (x, y, w, h)
    
    # 选择自己感兴趣区域的像素,并转到HSV颜色空间(用于后续的反投影中)
    interested_frame = frame[y:y+h, x:x+w]  # 根据自己的目标预期的位置设定该区域
    hsv_img = cv2.cvtColor(interested_frame, cv2.COLOR_BGR2HSV)
    
    # 计算感兴趣区域的色调直方图
    mask = None  # 不设置掩膜
    interested_hist = cv2.calcHist([hsv_img], [0], mask, [180], [0, 180])  # 0表示只用通道一来计算直方图,每个通道直方图使用180bin,每个bin值的范围从0到180
    cv2.normalize(interested_hist, interested_hist, 0, 255, cv2.NORM_MINMAX)  # 将值规范到0到255
    term_criterion = (cv2.TERM_CRITERIA_COUNT | cv2.TERM_CRITERIA_EPS, 10, 1)  # 分别代表迭代十次之后或者像素点移动不超过1像素停止(因为该算法本身就是在不断调整矩形所在位置,即像素移动)
    
    # 开始循环
    success, frame = cap.read()
    frame = cv2.flip(frame, 1)
    while success:
        hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
        back_proj = cv2.calcBackProject([hsv], [0], interested_hist, [0, 180], 1)  # 此处的0和180应该与之前的直方图保持一致,1表示不返回新的数组作为反投影
    # 正式运行
        num_iters, track_window = cv2.meanShift(back_proj, track_window, term_criterion)
    
        # 绘制最终的成果
        x, y, w, h = track_window
        cv2.rectangle(frame, (x, y), (x+w, y+h), (255, 0, 0), 2)
        cv2.imshow('back-projection', back_proj)
        cv2.imshow('meanshift', frame)
    
        if cv2.waitKey(1) == 27:
            break
    
        success, frame = cap.read()
        frame = cv2.flip(frame, 1)
    
    # 关闭摄像头和所有窗口
    cap.release()
    cv2.destroyAllWindows()

    效果确实很好,不会被突然出现的物体影响本人也是初学者,如有错误,欢迎指出!

    更多相关内容
  • 主要为大家详细介绍了Opencv光流运动物体追踪的相关资料,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 简单几行就可以实现对动态物体追踪,足见opencv在图像处理上的强大。 python代码: import cv2 import numpy as np camera=cv2.VideoCapture(0) firstframe=None while True: ret,frame = camera.read() if not...
  • 本文实现对特定颜色的物体追踪,我实验用的是绿萝的树叶。 新建脚本ball_tracking.py,加入代码: import argparse from collections import deque import cv2 import numpy as np 导入必要的包,然后定义一些函数 ...

    本文实现对特定颜色的物体追踪,我实验用的是绿萝的树叶。

    新建脚本ball_tracking.py,加入代码:

    import argparse
    from collections import deque
    import cv2
    import numpy as np
    

    导入必要的包,然后定义一些函数

    def grab_contours(cnts):
        # 如果 cv2.findContours 返回的轮廓元组的长度为“2”,那么我们使用的是 OpenCV v2.4、v4-beta 或 v4-official
        if len(cnts) == 2:
            cnts = cnts[0]
        # 如果轮廓元组的长度为“3”,那么我们使用的是 OpenCV v3、v4-pre 或 v4-alpha
        elif len(cnts) == 3:
            cnts = cnts[1]
        else:
            raise Exception(("Contours tuple must have length 2 or 3, "
                "otherwise OpenCV changed their cv2.findContours return "
                "signature yet again. Refer to OpenCV's documentation "
                "in that case"))
        return cnts
    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
    
    

    grab_contours 对于opencv不同版本做了兼容处理。

    resize等比例改变图片的大小。

     命令行参数
    ap = argparse.ArgumentParser()
    ap.add_argument("-v", "--video", help="path to video")
    ap.add_argument("-b", "--buffer", type=int, default=64, help="max buffer size")
    args = vars(ap.parse_args())
    # 绿色树叶的HSV色域空间范围
    greenLower = (29, 86, 6)
    greenUpper = (64, 255, 255)
    pts = deque(maxlen=args["buffer"])
    vs = cv2.VideoCapture(0)
    fps = 30    #保存视频的FPS,可以适当调整
    size=(600,450)
    fourcc=cv2.VideoWriter_fourcc(*'XVID')
    videowrite=cv2.VideoWriter('output.avi',fourcc,fps,size)
    

    定义参数

    –video :视频文件的路径或者摄像头的id

    –buffer 是 deque 的最大大小,它维护我们正在跟踪的球的先前 (x, y) 坐标列表。 这个双端队列允许我们绘制球的“轨迹”,详细说明它过去的位置。 较小的队列将导致较短的尾部,而较大的队列将产生较长的尾部

    定义hsv空间的上限和下限

    启动摄像头0

    最后是保存定义VideoWriter对象,实现对视频的写入功能

    while True:
        ret_val, frame = vs.read()
        if ret_val is False:
            break
        frame = resize(frame, width=600)
        # 通过高斯滤波去除掉一些高频噪声,使得重要的数据更加突出
        blurred = cv2.GaussianBlur(frame, (11, 11), 0)
        # 将图片转为HSV
        hsv = cv2.cvtColor(blurred, cv2.COLOR_BGR2HSV)
        # inRange的作用是根据阈值进行二值化:阈值内的像素设置为白色(255),阈值外的设置为黑色(0)
        mask = cv2.inRange(hsv, greenLower, greenUpper)
        # 腐蚀(erode)和膨胀(dilate)的作用:
        # 1. 消除噪声;
        # 2. 分割(isolate)独立的图像元素,以及连接(join)相邻的元素;
        # 3. 寻找图像中的明显的极大值区域或极小值区域
        mask = cv2.erode(mask, None, iterations=2)
        mask = cv2.dilate(mask, None, iterations=2)
       
    

    开启一个循环,该循环将一直持续到 (1) 我们按下 q 键,表明我们要终止脚本或 (2) 我们的视频文件到达终点并用完帧。

    读取一帧,返回两个参数,第一个参数是否成功,第二个参数是一帧图像。

    如果失败则break。

    对图像进行了一些预处理。首先,我们将框架的大小调整为 600 像素的宽度。缩小帧使我们能够更快地处理帧,从而提高 FPS(因为我们要处理的图像数据更少)。然后我们将模糊框架以减少高频噪声,并使我们能够专注于框架内的结构物体,例如球。最后,我们将帧转换为 HSV 颜色空间。

    通过调用 cv2.inRange 处理帧中绿球的实际定位。首先为绿色提供下 HSV 颜色边界,然后是上 HSV 边界。 cv2.inRange 的输出是一个二进制掩码,

    image-20211217152000441

     # 寻找轮廓,不同opencv的版本cv2.findContours返回格式有区别,所以调用了一下imutils.grab_contours做了一些兼容性处理
        cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
        cnts = grab_contours(cnts)
        center = None
        # only proceed if at least one contour was found
        if len(cnts) > 0:
            # find the largest contour in the mask, then use it to compute the minimum enclosing circle
            # and centroid
            c = max(cnts, key=cv2.contourArea)
            ((x, y), radius) = cv2.minEnclosingCircle(c)
            M = cv2.moments(c)
            # 对于01二值化的图像,m00即为轮廓的面积, 一下公式用于计算中心距
            center = (int(M["m10"] / M["m00"]), int(M["m01"] / M["m00"]))
            # only proceed if the radius meets a minimum size
            if radius > 10:
                # draw the circle and centroid on the frame, then update the list of tracked points
                cv2.circle(frame, (int(x), int(y)), int(radius), (0, 255, 255), 2)
                cv2.circle(frame, center, 5, (0, 0, 255), -1)
    
            pts.appendleft(center)
    
        for i in range(1, len(pts)):
            # if either of the tracked points are None, ignore them
            if pts[i - 1] is None or pts[i] is None:
                continue
    
            # compute the thickness of the line and draw the connecting line
            thickness = int(np.sqrt(args["buffer"] / float(i + 1)) * 2.5)
            cv2.line(frame, pts[i - 1], pts[i], (0, 0, 255), thickness)
    
        cv2.imshow("Frame", frame)
        videowrite.write(frame)
        key = cv2.waitKey(1) & 0xFF
    
        if key == ord("q"):
            break
    videowrite.release()
    vs.release()
    cv2.destroyAllWindows()
    

    计算图像中对象的轮廓。在接下来的行中,将球的中心 (x, y) 坐标初始化为 None。

    检查以确保在掩码中至少找到一个轮廓。假设至少找到一个轮廓,找到 cnts 列表中最大的轮廓,计算 blob 的最小包围圆,然后计算中心 (x, y) 坐标(即“质心”)。

    快速检查以确保最小包围圆的半径足够大。如果半径通过测试,我们然后画两个圆圈:一个围绕球本身,另一个表示球的质心。

    然后,将质心附加到 pts 列表中。

    循环遍历每个 pts。如果当前点或前一个点为 None(表示在该给定帧中没有成功检测到球),那么我们忽略当前索引继续循环遍历 pts。

    如果两个点都有效,我们计算轨迹的厚度,然后将其绘制在框架上。

    运行结果:

    展开全文
  • 主要为大家详细介绍了OpenCV3.0+Python3.6实现特定颜色的物体追踪,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • OpenCV是一个基于BSD许可(开源)发行的跨平台计算机视觉库,可以运行在Linux、Windows、Android和Mac OS操作系统上。这篇文章主要介绍了如何用OpenCV -python3实现视频物体追踪,需要的朋友可以参考下
  • 移动物体追踪C#DlibDotNet
  • 物体追踪过程中,联机多分类器在对物体定位的同时还能估计物体的姿态,能够成功地学习多模态外观模型,在物体外观快速变化的情况下追踪物体。实验结果表明:所提算法在经过一个较短序列的训练后,平均追踪错误率为...
  • OpenCV杂谈_08 一. 需要做的前期准备 ...一段提前录制好的用于物体检测、追踪的视频(要求:摄像头是保持静止不动的) 一个用的顺手的IDE(本人推荐Pycharm) 二. 源码如下 main.py 文件 ...

    OpenCV杂谈_08


    一. 需要做的前期准备

    1. 环境配置:
      Python版本:3.9.0
      功能包:opencv-python(4.5.2.52)、math(自带)
    2. 一段提前录制好的用于物体检测、追踪的视频(要求:摄像头是保持静止不动的)
    3. 一个用的顺手的IDE(本人推荐Pycharm)

    二. 源码如下

    1. main.py 文件
    import cv2
    from tracker import *
    
    # 进行追踪
    tracker = EuclideanDistTracker()  # 这个函数通过获取同一物体不同时刻的boundingbox的坐标从而实现对其的追踪
    
    # 导入想要进行tracking的视频,要求拍摄视频的过程中摄像头是保持静止状态的
    cap = cv2.VideoCapture("highway.mp4")
    
    # 从导入的视频中找到正在移动的物体
    object_detector = cv2.createBackgroundSubtractorMOG2(history=100, varThreshold=40)  # 对参数进行调整则会改变捕捉移动物体的精准性
    
    while True:
        ret, frame = cap.read()
        height, width, _ =frame.shape  # 得出视频画面的大小,从而去方便计算出感兴趣区域所在的位置
        print(height, width)  # 720,1280
    
        # 设置一个感兴趣区域,让处理(对物体的detection和tracking)只关注于感兴趣区域,从而减少一些计算量也让检测变得简单一些
        roi = frame[340: 720, 500: 800]
    
        # 物体检测  (根据需要可以将该部分代码换成比如行人检测、汽车检测等等)
        mask = object_detector.apply(roi)  # 通过加一个蒙版,更加清晰的显示出移动中的物体,即只留下白色的移动的物体。
        _, mask = cv2.threshold(mask, 254, 255, cv2.THRESH_BINARY)  # 去除移动物体被检测到的时候所附带的阴影(阴影为灰色)
        contours, _ = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)  # 找到视频中物体的轮廓
        detections = []  # 用于存放boundingbox的起始点坐标、宽、高
        for cnt in contours:
            # 计算出每个轮廓内部的面积,并根据面积的大小去除那些不必要的噪声(比如树、草等等)
            area = cv2.contourArea(cnt)
            if area > 100:
                # cv2.drawContours(roi, [cnt], -1, (0, 255, 0), 2)  # 画出移动物体的轮廓
                x, y, w, h = cv2.boundingRect(cnt)
                detections.append([x, y, w, h])
    
    
        # 物体追踪
        boxer_ids = tracker.update(detections)  # 同一个物体会有相同的ID
        # print(boxer_ids)
        for box_id in boxer_ids:
            x, y, w, h, id = box_id
            cv2.putText(roi, "Obj" + str(id), (x, y - 15), cv2.FONT_ITALIC, 0.7, (255, 0, 0), 2)
            cv2.rectangle(roi, (x, y), (x + w, y + h), (0, 255, 0), 2)  # 根据移动物体的轮廓添加boundingbox
    
        print(detections)
        cv2.imshow("Frame", frame)  # 打印结果
        # cv2.imshow("Mask", mask)  # 打印出蒙版
        # cv2.imshow("ROI", roi)  # 打印出你想要的ROI在哪
        key = cv2.waitKey(30)
        if key == 27:
            break
    
    cap.release()
    cv2.destroyAllWindows()
    
    1. tracker.py文件
    import math
    
    
    class EuclideanDistTracker:
        def __init__(self):
            # Store the center positions of the objects
            self.center_points = {}
            # Keep the count of the IDs
            # each time a new object id detected, the count will increase by one
            self.id_count = 0
    
    
        def update(self, objects_rect):
            # Objects boxes and ids
            objects_bbs_ids = []
    
            # Get center point of new object
            for rect in objects_rect:
                x, y, w, h = rect
                cx = (x + x + w) // 2
                cy = (y + y + h) // 2
    
                # Find out if that object was detected already
                same_object_detected = False
                for id, pt in self.center_points.items():
                    dist = math.hypot(cx - pt[0], cy - pt[1])
    
                    if dist < 25:
                        self.center_points[id] = (cx, cy)
                        print(self.center_points)
                        objects_bbs_ids.append([x, y, w, h, id])
                        same_object_detected = True
                        break
    
                # New object is detected we assign the ID to that object
                if same_object_detected is False:
                    self.center_points[self.id_count] = (cx, cy)
                    objects_bbs_ids.append([x, y, w, h, self.id_count])
                    self.id_count += 1
    
            # Clean the dictionary by center points to remove IDS not used anymore
            new_center_points = {}
            for obj_bb_id in objects_bbs_ids:
                _, _, _, _, object_id = obj_bb_id
                center = self.center_points[object_id]
                new_center_points[object_id] = center
    
            # Update dictionary with IDs not used removed
            self.center_points = new_center_points.copy()
            return objects_bbs_ids
    

    三. 结果展示

    by demo

    四. 感悟与分享

    1. 可以看出来由于物体的检测方法是根据视频中谁在运动而进行挑选的,因此在准确度上有些许问题且无法获得物体的分类信息,而且为了减少计算量而设置了ROI区域,而并非是全画面的物体检测与追踪。未来如果想实现相对高精度的检测与追踪,则需要调用Cascade文件来进行物体检测,从而实现较高精度的且附带分类信息的识别、追踪结果。
    2. 参考课程及推荐:https://www.youtube.com/watch?v=O3b8lVF93jU(内容为英文,且需要翻墙)

    如有问题,敬请指正。欢迎转载,但请注明出处。
    展开全文
  • 光流法,利用图像中像素点与时间的关系构建,可用于物体追踪
  • 物体追踪

    千次阅读 2018-12-17 13:15:19
    什么是物体追踪? 简单地说,在视频的连续帧中定位对象被称为追踪。 用opencv2简单实现对象跟踪 在我们的程序中,我们要追踪一个蓝色的物体。下面就是就是我们要做的几步: • 从视频中获取每一帧图像 • 将...

    什么是物体追踪?

    简单地说,在视频的连续帧中定位对象被称为追踪。

    用opencv2简单实现对象跟踪

    在我们的程序中,我们要追踪一个蓝色的物体。下面就是就是我们要做的几步:
    • 从视频中获取每一帧图像
    • 将图像转换到 HSV 空间
    • 设置 HSV 阈值到蓝色范围。
    • 获取蓝色物体,当然我们还可以做其他任何我们想做的事,比如:在蓝色 物体周围画一个圈。

    需要的库

    • cv2

       pip install opencv-python
      
    • numpy

    代码示例

    #coding:utf-8
    import cv2
    import numpy as np
    
    cap = cv2.VideoCapture(0)
    
    while(1):
    
        # 获取每一帧
        _, frame = cap.read()
    
        # 转到HSV
        hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
    
        # 设定蓝色阈值
        lower_blue = np.array([110,50,50])
        upper_blue = np.array([130,255,255])
    
        # 根据阈值构建掩模
        mask = cv2.inRange(hsv, lower_blue, upper_blue)
    
        # 对原图像和掩模进行位运算
        res = cv2.bitwise_and(frame,frame, mask= mask)
        #显示图片
        cv2.imshow('frame',frame)
        cv2.imshow('mask',mask)
        cv2.imshow('res',res)
        k = cv2.waitKey(5) & 0xFF
        #按Esc退出
        if k == 27:
            break
    #关闭窗口
    cv2.destroyAllWindows()
    

    输出结果

    在这里插入图片描述

    函数详解

    1.VideoCapture()

    VideoCapture()中参数是0,表示打开笔记本的内置摄像头,参数是视频文件路径则打开视频,如cap = cv2.VideoCapture(“…/test.avi”)

    2. cap.read()

    功 能:返回两个值
    先返回一个布尔值,如果视频读取正确,则为 True,
    如果错误,则为 False,也可用来判断是否到视频末尾再返回一个值,为每一帧的图像,该值是一个三维矩阵
    通用接收方法为:

    ret,frame = cap.read();
    

    这样 ret 存储布尔值,frame 存储图像
    若使用一个变量来接收两个值,如

    frame = cap.read()
    

    则 frame 为一个元组,原来使用 frame 处需更改为 frame[1]
    返回值:R1:布尔值
    R2:图像的三维矩阵
    cap = cv2.VideoCapture(0)

    3. cv2.cvtColor()

    opencv中颜色空间转换函数 cv2.cvtColor()

    opencv中有多种色彩空间,包括 RGB、HSI、HSL、HSV、HSB、YCrCb、CIE XYZ、CIE Lab8种,使用中经常要遇到色彩空间的转化,以便生成mask图等操作。

    HSV 表示hue、saturation、value
    可以使用下面的色彩空间转化函数 cv2.cvtColor( )进行色彩空间的转换:

    image_hsv = cv2.cvtColor(image,cv2.COLOR_BGR2HSV)
    
    转换颜色空间

    在opencv中有超过150种颜色空间转换方法(震惊-_-)
    但是经常用的只有BGR-灰度图和BGR-HSV
    使用函数cv2.cvtColor(input_image ,flag),flag是转换类型
    BGR和灰度图的转换使用 cv2.COLOR_BGR2GRAY
    BGR和HSV的转换使用 cv2.COLOR_BGR2HSV

    使用如下命令可以得到可以使用的flags

    import cv2
    import numpy as np
    
    flags = [i for i in dir(cv2) if i.startswith('COLOR_')]
    
    print(flags)
    

    HSV空间中,H表示色彩/色度,取值范围 [0,179],
    S表示饱和度,取值范围 [0,255],
    V表示亮度,取值范围 [0,255]。
    但是不同的软件使用值不同

    4. cv2.inRange

    利用cv2.inRange函数设阈值,去除背景部分

    mask = cv2.inRange(hsv, lower_blue, upper_blue)
    

    函数很简单,参数有三个

    第一个参数:hsv指的是原图

    第二个参数:lower_blue指的是图像中低于这个lower_blue的值,图像值变为0

    第三个参数:upper_blue指的是图像中高于这个upper_blue的值,图像值变为0

    而在lower_red~upper_red之间的值变成255

    5.图像的位运算

    图像的基本运算有很多种,比如两幅图像可以相加、相减、相乘、相除、位运算、平方根、对数、绝对值等;图像也可以放大、缩小、旋转,还可以截取其中的一部分作为ROI(感兴趣区域)进行操作,各个颜色通道还可以分别提取及对各个颜色通道进行各种运算操作。总之,对于图像可以进行的基本运算非常的多,只是挑了些常用的操作详解。

    bitwise_and是对二进制数据进行“与”操作,即对图像(灰度图像或彩色图像均可)每个像素值进行二进制“与”操作,1&1=1,1&0=0,0&1=0,0&0=0
    bitwise_or是对二进制数据进行“或”操作,即对图像(灰度图像或彩色图像均可)每个像素值进行二进制“或”操作,1|1=1,1|0=0,0|1=0,0|0=0
    bitwise_xor是对二进制数据进行“异或”操作,即对图像(灰度图像或彩色图像均可)每个像素值进行二进制“异或”操作,11=0,10=1,01=1,00=0
    bitwise_not是对二进制数据进行“非”操作,即对图像(灰度图像或彩色图像均可)每个像素值进行二进制“非”操作,1=0,0=1

    6.掩模详细介绍

    https://blog.csdn.net/u011028345/article/details/77278467

    7.

        k = cv2.waitKey(5) & 0xFF
        #按Esc退出
        if k == 27:
            break
    

    waitKey(5) 中的数字代表等待按键输入之前的无效时间,单位为毫秒,在这个时间段内按键 ‘Esc‘ (Esc的值为27)不会被记录,在这之后按键才会被记录。
    也即经过无效时间以后,检测在上一次显示图像的时间段内按键 ‘Esc’ 有没有被按下,若无则跳出if语句段,捕获并显示下一帧图像。

    若此参数置零,则代表在捕获并显示了一帧图像之后,程序将停留在if语句段中一直等待 ‘Esc’ 被键入。

    cv2.waitKey(1) 与 0xFF(1111 1111)相与是因为cv2.waitKey(1) 的返回值不止8位,但是只有后8位实际有效,为避免产干扰,通过 ‘与’ 操作将其余位置0。

    展开全文
  • 树莓派小车物体追踪

    2017-12-04 23:18:38
    本文讲述如何利用opencv和python实现树莓派小车物体追踪的目标。包含告诉大家如何安装opencv3.0和如何利用它实现我的小车避障以及对应的python程序
  • 物体追踪源程序

    2013-03-27 14:47:44
    这是一个VC++的物体追踪和分析代码 运用了OPENCV摄像头识别物体的函数 实现了移动物体追踪的功能 可以作为物体识别跟踪的参考代码
  • 深度学习移动物体追踪源码范例
  • 前言 第三节课实现的是通过掩膜提取物体的颜色从而达到物体追踪的功能。 1.获取视频流 2.颜色空间转换 RGB—>HSV 设置 HSV 的阈值 3.识别并追踪物体 代码 import numpy as np import cv2 yellow_lower=np.array([9,...
  • 在开发树莓派智能小车的路上...所以开始琢磨着让我自己的小车也加上物体追踪的功能。在几天的资料整理之后发现是利用opencv和python实现的。那么今天告诉大家如何安装opencv3.0和如何利用它实现我的小车追踪。之前确...
  • 功能介绍:这是采用QT设计的一个摄像头人脸追踪的云台控制上位机,通过ffmpeg播放海康摄像头的rtsp流,检测画面里最大的人脸,获取人脸在图像里的坐标后,经过换算,控制云台完成人脸追踪。 资料包里包含整体的QT...
  • 本小车系统主要基于一片IAP15F2K61S2单片机实现功能。整个系统可分为四个部分,核心控制部分、信息探测部分、动作执行部分和辅助部分。
  • 在OpenCV和C++的框架下实现的,这个程序可以在.Net下运行,并且返回位置的坐标和跟踪物体
  • 正所谓的光流估计,就是在视频的前后帧的分析中,能分析出图中的一些object的移动方向和速度,可以做目标追踪使用。 Lucas-Kanade算法改进 经典的光流估计是Lucas-Kanade 算法,这个算法是基于下列的三个基本假设: ...
  • 物联网-智慧交通-传感器网络中高效移动物体追踪研究.pdf
  • opencv移动物体追踪

    千次阅读 2019-08-22 15:50:22
    本次试验用的WINFORM ,要先绘制窗体 ,自己测试的时候注意对象名就可以了。 public Form1() { InitializeComponent(); } static Mat mat1 = new Mat(@"timg.jpg", ImreadModes.AnyColor); ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 20,010
精华内容 8,004
关键字:

物体追踪