精华内容
下载资源
问答
  • openmv学习之旅②之色块追踪算法的改善

    万次阅读 多人点赞 2018-06-05 13:10:12
    大家好,我是杰杰。...Python这个东西用起来是很简单的,,下面来说说改善色块追踪的算法先做个改善前的分析吧:改善前:API:find_blobsthresholds是颜色的阈值。这个参数是一个列表,可以包含多个颜色。在返回...

    大家好,我是杰杰。

    实在不好意思,最近比较忙,之前说的连载现在才更新出来。


    从上一篇openmv的学习中openmv学习之旅①
    我们可以很简单运用micropython在openmv上做我们想做的事情。

    Python这个东西用起来是很简单的,,下面来说说改善色块追踪的算法

    先做个改善前的分析吧:

    改善前:


    API:find_blobs


    • thresholds是颜色的阈值。这个参数是一个列表,可以包含多个颜色。在返回的色块对象blob可以调用code方法,来判断是什么颜色的色块。

    • roi是“感兴趣区”。

    • x_stride 就是查找的色块的x方向上最小宽度的像素,默认为2。

    • y_stride 就是查找的色块的y方向上最小宽度的像素,默认为1。

    • area_threshold 面积阈值,如果色块被框起来的面积小于这个值,会被过滤掉。

    • pixels_threshold 像素个数阈值,如果色块像素数量小于这个值,会被过滤掉

    • merge 合并,如果设置为True,那么合并所有重叠的blob为一个。 注意:这会合并所有的blob,无论是什么颜色的。如果你想混淆多种颜色的blob,只需要分别调用不同颜色阈值的find_blobs。

      1blobs = img.find_blobs([red])

    find_blobs对象返回的是多个blob的列表。

    而一个blobs列表里包含很多blob对象,blobs对象就是色块,每个blobs对象包含一个色块的信息。


    blob有多个方法:

    • blob.rect() 返回这个色块的外框——矩形元组(x, y, w, h),可以直接在image.draw_rectangle中使用。

    • blob.x() 返回色块的外框的x坐标(int),也可以通过blob[0]来获取。

    • blob.y() 返回色块的外框的y坐标(int),也可以通过blob[1]来获取。

    • blob.w() 返回色块的外框的宽度w(int),也可以通过blob[2]来获取。

    • blob.h() 返回色块的外框的高度h(int),也可以通过blob[3]来获取。

    • blob.pixels() 返回色块的像素数量(int),也可以通过blob[4]来获取。

    • blob.cx() 返回色块的外框的中心x坐标(int),也可以通过blob[5]来获取。

    • blob.cy() 返回色块的外框的中心y坐标(int),也可以通过blob[6]来获取。

    • blob.rotation() 返回色块的旋转角度(单位为弧度)(float)。如果色块类似一个铅笔,那么这个值为0~180°。如果色块是一个圆,那么这个值是无用的。如果色块完全没有对称性,那么你会得到0~360°,也可以通过blob[7]来获取。

    • blob.code() 返回一个16bit数字,每一个bit会对应每一个阈值。

      (上面的知识在openmv的官网上都有说明)

    下面是说说调用find_blobs来做色块的追踪的原理

    它是全幅图像扫描,它有优点也有缺点

    先说说优点吧:信息全面,全幅图像的搜索,把所有色块都搜索进来了

    但是缺点也不少:①:运算的速度,是很慢的,有些地方我们根本不需要扫描它。

    ②:色块的数量,很多时候,会有很多延时差不多的色块过来干扰,导致追踪失败。

    源码:

     1import sensor, image, time
     2red_threshold_01 = (0, 35, 0, 50, -10, 40)
     3sensor.reset() 
     4sensor.set_pixformat(sensor.RGB565)
     5sensor.set_framesize(sensor.QVGA) 
     6sensor.skip_frames(10) 
     7sensor.set_auto_whitebal(False)
     8clock = time.clock()
     9while(True):
    10    clock.tick()
    11    img = sensor.snapshot() 
    12    blobs = img.find_blobs([red_threshold_01],
    13                             area_threshold=150)
    14    if blobs:
    15    #如果找到了目标颜色
    16        print(blobs)
    17        for b in blobs:
    18        #迭代找到的目标颜色区域
    19            # Draw a rect around the blob.
    20            img.draw_rectangle(b[0:4]) # rect
    21            #用矩形标记出目标颜色区域
    22            img.draw_cross(b[5], b[6]) # cx, cy
    23            #在目标颜色区域的中心画十字形标记
    24    print(clock.fps())




    效果图:

    捕获.PNG

    运算速度:

    微信截图_20180306223742.png

    从拍摄完到扫描完,每秒只能处理二十多帧图像,而且是简单的处理。

    虽然脱机运行速度可以快一倍。但是还是比较慢的。

    肯定要改进啊。


    以下是改进扫描算法的思想:

    ①:首先做一次全幅图像的扫描,找到我们需要的色块。

    ②:我们得到色块的信息:如色块的长、宽、及色块的位置

    ③:我们只扫描色块周围的区域(ROI)

    ④:假设在新的ROI找不到我们需要的色块,就重新来。

    这个方法类似于飞思卡尔的边缘检测。

    其实这个改进是非常简单的。因为我们需要的东西在microPython中全部都有。

    只需要拿到find_blobs的返回的东西就好啦。

    算法示意图

    640.jpg


    绿色的是我们追踪的色块,

    而红色的框是我们第一次全局扫描得到的东西

    那么我们只需在红色的框之外做一次扫描就能得到绿色块啦

    实现的源码

     1import sensor, image, time
     2#red_threshold_01 = (45, 100, -60, 80, 34, 91)
     3red_threshold_01 = (21, 29, -72, 6, -11, 17)
     4sensor.reset() 
     5sensor.set_pixformat(sensor.RGB565)
     6sensor.set_framesize(sensor.QVGA) 
     7sensor.skip_frames(20) 
     8sensor.set_auto_whitebal(False)
     9#关闭白平衡。白平衡是默认开启的,在颜色识别中,需要关闭白平衡
    10clock = time.clock() 
    11img = sensor.snapshot()
    12blobs = img.find_blobs([red_threshold_01],
    13                         area_threshold=150)
    14last_blobs = blobs
    15while(True):
    16    clock.tick() 
    17    img = sensor.snapshot() 
    18    if last_blobs:
    19         for b in blobs:
    20            x1 = b[0]-7
    21            y1 = b[1]-7
    22            w1 = b[2]+12
    23            h1 = b[3]+12
    24            #print(b.cx(),b.cy())
    25         roi2 = (x1,y1,w1,h1)
    26         print(roi2)
    27         blobs = img.find_blobs([red_threshold_01],
    28                                    roi = roi2,
    29                                    area_threshold=1000)
    30         last_blobs = blobs
    31    else:
    32        blobs = img.find_blobs([red_threshold_01],
    33                                    area_threshold=1000)
    34        last_blobs = blobs
    35    if last_blobs:
    36        #如果找到了目标颜色
    37        #  print(blobs)
    38        for b in last_blobs:#迭代找到的目标颜色区域
    39            img.draw_rectangle(b[0:4]) 
    40            img.draw_cross(b[5], b[6]) 
    41    print("帧率 : ",clock.fps()) 

    改善后的帧率的确是快了不少的:基本能快一倍以上,当然,物体在图片越大,处理的速度会越慢。

    微信截图_20180306223943.png

    帧率达到了  45  ,并且,对于运动中的物体,也能很好的追踪出来,减少无关物体的干扰。


    按照这个思想,我们还能把这个物体分成四条边来扫描:

    640 (1).jpg

    那么是不是只需要扫描到这个物体的四条边,并且证明四条边的点都有重合,那么,我们就能知道这个物体是一个整体从而得到物体的位置。。。。

    当然,这只是想法。对于程序员任何的功能想法的实现都需要代码的实现,这代码我就不实现了,有兴趣的可以试试。。。


    展开全文
  • 基于STM32F407和OV5640的视觉算法,当时在做全国大学生工程训练大赛,二维码识别采用的是正点原子的库;颜色识别自己写的算法,只识别红绿蓝,直接对RGB进行算法判定,不需要...色块追踪写来玩的,参考了其他人的算法。
  • Openmv色块追踪

    2019-09-27 20:31:08
    Openmv 拿到后第一次进行开发(颜色追踪) ###Openmv本身是具有很多的内置函数的,基本都是别人给我们写好了,需要我们自己去调用,并给函数传递参数以实现我们需要的效果。但是很多初学者开始并不知道该如何开始我...

    Openmv 拿到后第一次进行开发(颜色追踪)

    Openmv本身是具有很多的内置函数的,基本都是别人给我们写好了,需要我们自己去调用,并给函数传递参数以实现我们需要的效果。但是很多初学者开始并不知道该如何开始我也是作为第一次接触的新手,为了让爱好Openmv的同学少走弯路,特意把我第一次接触的过程写下来。

    一.拿到Openmv后,先下载Openmv IDE 下面是我百度分享的Openmv IDE

    百度网盘地址

    提取码:vd5m

    安装过程很简单,正常安装软件步骤,一直下一步就好。

    软件安装好了以后,用Openmv 自带的USB下载线连接电脑和Openmv,连接好USB数据线后点击这里
    在点击完之后连续弹出3个提示框,不用在意,一直点击否就可以

    点击这里在这里插入图片描述此时IDE右上角会显示Openmv拍摄到的画面(如果不显示画面,可以检查一下Openmv和电脑插上USB连接线后有没有多出一个U盘 盘符 如果没有,则说明Openmv没有和电脑连接成功,检查一下驱动和Openmv,数据线是否损坏)

    显示画面后,第一步骤就完成了

    二.导入官方颜色追踪代码,这里我也把代码文件分享给大家

    链接:https://pan.baidu.com/s/1Gl0a6GjkIleaOz-365H3mQ
    提取码:annt

    解压完代码后,复制OpenMV-Pan-Tilt-master\pan-tilt\src目录下的main.py和pid.py两个文件.并将复制的文件粘贴到连接Openmv后出现的U盘中(注意替换掉U盘中存在的main.py文件)

    在这里插入图片描述这两个文件一个是舵机PID算法,一个是主函数的文件,没有云台舵机也么问题,一样可以实现的。以后会更新对着两个文件的详细介绍和分析

    准备工作到此做完,最后打开编译器(IDE),在这里插入图片描述点击箭头的 × 将原来的文件删除 将U盘中的main.py和pid.py两个文件拖动到空白位置或者直接拖动到编译器图标中
    在这里插入图片描述
    最后按照上面的操作打开摄像头,显示界会有一个小十字箭头指着一块红色的区域,到此为止颜色追踪结束。(以后我会更新对该算法的解析和人脸识别的实现过程以及我对Openmv学习过程)
    在这里插入图片描述

    展开全文
  • 【openMV】色块追踪

    2019-09-28 09:25:35
    实现色块扫描、返回最大色块的中心位置,相对距离,颜色数据。 从图像返回的参考坐标系变换到二维笛卡尔坐标系: Blob_X = (MVData[3]<<8)+MVData[4]; Blob_Y = (MVData[5]<<8)+MVData[6]; Blob_X = ...

     实现色块扫描、返回最大色块的中心位置,相对距离,颜色数据。

    从图像返回的参考坐标系变换到二维笛卡尔坐标系:

    Blob_X = (MVData[3]<<8)+MVData[4];
    Blob_Y = (MVData[5]<<8)+MVData[6];
    Blob_X = Blob_X-160;//变换到二维平面坐标系
    Blob_Y = 120-Blob_Y;

    '''
    颜色追踪信令包
    0&1、包头0xAA、0xAF
    2、颜色标志位-->0:无、1:红色、2黄色
    3-6-->色块位置数据
    3、x轴高位
    4、x轴低位
    5、y轴高位
    6、y轴低位
    7、相对于二维平面原点的距离
    '''
    import sensor, image, time, math
    from pyb import UART
    uart = UART(3,9600)
    thresholds_yellow = (50, 90, -32, 23, 20, 64)#黄色色块LAB阈值
    #thresholds_blue = (46, 95, -34, 19, -45, -11)
    thresholds_red  = (41, 73, 46, 94, 1, 77)
    
    class clo_blob():
        flag = 0    #0无1红2蓝
        #最大色块中心坐标
        position_x_H = 0            #x高八位
        position_x_L = 0            #x低八位
        position_y_H = 0            #y高八位
        position_y_L = 0            #y低八位
        Distance = 0                #相对于(160,120)的距离
    
    
    def Print_Blob(obj,flag):
        tem.flag = flag
        #色块中心坐标分解传输
        tem.position_x_H = obj.cx()>>8
        tem.position_x_L = obj.cx()
        tem.position_y_H = obj.cy()>>8
        tem.position_y_L = obj.cy()
        tem.Distance = int(math.sqrt(math.pow(obj.cx()-160,2) + math.pow(obj.cy()-120,2)))
        #print(tem.Distance)
        #print("X:{}  Y:{}".format(obj.cx()-160,120-obj.cy()))
        Data_Print = bytearray([0xAA,0xAF,
        tem.flag,
        tem.position_x_H,tem.position_x_L,
        tem.position_y_H,tem.position_y_L,
        tem.Distance])
    
        return Data_Print
    
    sensor.reset()
    sensor.set_pixformat(sensor.RGB565)
    sensor.set_framesize(sensor.QVGA)
    sensor.skip_frames(time = 2000)
    sensor.set_auto_gain(False)
    sensor.set_auto_whitebal(False)
    clock = time.clock()
    _roi = [0,0,320,240]#完整屏幕
    
    tem = clo_blob()
    Zero_return = bytearray([0xAA,0xAF,
        0x00,0x00,0x00,0x00,0x00,0x00,0x00])#未发现色块返回此数组
    count = 0
    flag_send = 0
    while(True):
        clock.tick()
        img = sensor.snapshot()
        count = 0
        flag_send = 0
    
        for blob in img.find_blobs([thresholds_yellow], pixels_threshold=200, area_threshold=200, merge=True,roi=_roi):
        #筛选出最大黄色色块
            if count == 0:
                Max_blob = blob
                count += 1
            elif blob.pixels() > Max_blob.pixels():
                Max_blob = blob
        #标定输出黄色色块信息
        if count != 0:
            img.draw_edges(Max_blob.min_corners(), color=(0,0,0))
            img.draw_line(Max_blob.major_axis_line(), color=(0,0,0))
            img.draw_line(Max_blob.minor_axis_line(), color=(0,0,0))
            uart.write(Print_Blob(Max_blob,2))
            #print("yellow:",Max_blob)
            count = 0
            flag_send = 1
        for blob in img.find_blobs([thresholds_red], pixels_threshold=200, area_threshold=200, merge=True,roi=_roi):
        #筛选出最大红色色块
            if count == 0:
                Max_blob = blob
                count += 1
            elif blob.pixels() > Max_blob.pixels():
                Max_blob = blob
        #标定输出红色色块信息
        if count != 0:
            img.draw_edges(Max_blob.min_corners(), color=(0,0,0))
            img.draw_line(Max_blob.major_axis_line(), color=(0,0,0))
            img.draw_line(Max_blob.minor_axis_line(), color=(0,0,0))
            uart.write(Print_Blob(Max_blob,1))
            #print("red:",Max_blob)
            count = 0
            flag_send = 1
        if flag_send == 0:
            uart.write(Zero_return)
    

     

     

    展开全文
  • openmv配机器人的色块追踪

    千次阅读 2018-06-09 21:17:58
    #自动追踪红色小块,并根据机器人移动,找到红色小块import sensor, image, timefrom pyb import UARTfrom pyb import Pinprint("Tracking some color blocks!")#给stm32发送启动信息uart = UART(1, 9600...
    #自动追踪红色小块,并根据机器人移动,找到红色小块
    
    import sensor, image, time
    from pyb import UART
    from pyb import Pin


    print("Tracking some color blocks!")


    #给stm32发送启动信息
    uart = UART(1, 9600)
    uart.write("Waitting for beginning \r")


    #设置p_in为输入引脚,并开启上拉电阻
    p_in = Pin('P9', Pin.IN, Pin.PULL_UP)
    value = p_in.value()


    #等待32反馈
    while(not value):
        print("waitting for stm32/ardunio ")
        time.sleep(200)
    time.sleep(1000)


    #自动追踪开始工作
    sensor.reset()
    sensor.set_pixformat(sensor.RGB565)
    sensor.set_framesize(sensor.QVGA)
    sensor.skip_frames(time = 2000)
    sensor.set_auto_gain(False)
    sensor.set_auto_whitebal(False)
    clock = time.clock()


    #QVGA的色域中心
    r = [(320//2)-(50//2), (240//2)-(50//2), 50, 50]




    for i in range(60):
        img = sensor.snapshot()
        img.draw_rectangle(r)


    print("Learning thresholds...")
    threshold = [50, 50, 0, 0, 0, 0] # Middle L, A, B values.
    for i in range(60):
        img = sensor.snapshot()
        hist = img.get_histogram(roi=r)
        lo = hist.get_percentile(0.01) # Get the CDF of the histogram at the 1% range (ADJUST AS NECESSARY)!
        hi = hist.get_percentile(0.99) # Get the CDF of the histogram at the 99% range (ADJUST AS NECESSARY)!
        # Average in percentile values.
        threshold[0] = (threshold[0] + lo.l_value()) // 2
        threshold[1] = (threshold[1] + hi.l_value()) // 2
        threshold[2] = (threshold[2] + lo.a_value()) // 2
        threshold[3] = (threshold[3] + hi.a_value()) // 2
        threshold[4] = (threshold[4] + lo.b_value()) // 2
        threshold[5] = (threshold[5] + hi.b_value()) // 2
        for blob in img.find_blobs([threshold], pixels_threshold=150, \
                                   area_threshold=150, merge=False, margin=10):
            img.draw_rectangle(blob.rect())
            img.draw_cross(blob.cx(), blob.cy())
            img.draw_rectangle(r)


    #显示计数器
    fps_counter=0
    move_left_count=0
    move_right_count=0


    #事件计数器
    miss_count=0 #追踪丢失计数
    miss_check_count=0 #丢失检查计数
    blob_x=[] #记录blob.x
    blob_y=[] #记录blob.y
    blob_count=0


    #事件标志
    missing_flag=0


    #控制频率
    freq_move=32


    #开始进行图像处理
    while(True):
        clock.tick()
        img = sensor.snapshot()
        for blob in img.find_blobs([threshold], pixels_threshold=100, area_threshold=100, merge=True, margin=10):
            img.draw_rectangle(blob.rect())
            img.draw_cross(blob.cx(), blob.cy(),size=25,color=(0,0,0))


    #记录blob的左上角点坐标
        blob_count=blob_count+1
        if blob_count<17 :
            blob_x.append(blob.x())
            blob_y.append(blob.y())
        else :
            blob_count=0
            del blob_x[0]
            del blob_y[0]
            blob_x.append(blob.x())
            blob_y.append(blob.y())


    #判断是否追踪丢失


        miss_check_count=miss_check_count+1
        if miss_check_count==32:
            miss_check_count=0
            if blob_x[-1]==blob_x[-2] and \
               blob_x[-2]==blob_x[-3] and \
               blob_x[-3]==blob_x[-4] and \
               blob_x[-4]==blob_x[-5]:


                #连续五个坐标相同,可断定为目标丢失
                #并通知取消转向判断
                missing_flag=1
                print("Missing ! Missing ! ")
            else:
                missing_flag=0




    #打印当前刷新率


        fps_counter=fps_counter+1
        if fps_counter==16 :
            print(clock.fps())
            #test
            '''
            print(blob.x())
            print(blob.y())
            '''
            #test
            fps_counter=0


    #判断距离
        if blob.area() < 15000 and (not missing_flag):
            print("go head")








    #判断转向
        if blob.cx()>180 and blob.cx()<320 and (not missing_flag):
            move_right_count=move_right_count+1
            if move_right_count ==freq_move :
                print("move right !")
                move_right_count=0


                #通知
                #uart.write("r")






        elif blob.cx()>0 and blob.cx()<140 and (not missing_flag):
            move_left_count=move_left_count+1
            if move_left_count ==freq_move :
                print("move left !")
                move_left_count=0


                #通知
                #uart.write("l")
    展开全文
  • --------------------- static void ShowHelpText() { cout 此Demo显示了基于均值漂移的追踪(tracking)技术\n" "\t请用鼠标框选一个有颜色的物体,对它进行追踪操作\n"; cout 操作说明: \n" "\t\t用鼠标框选对象...
  • 而且颜色识别可以广泛应用于色块追踪, 巡线等机器人项目. 为了方便大家入门OpenCV以及使用OpenCV实现颜色识别, 阿凯编写了相关的上位机脚本, 同时也有. 刚开始的时候, 你的精力可以放在算法流程上面, 没必要在前期...
  • 一、一种色块的: from collections import deque import numpy as np import cv2 import time redLower = np.array([0, 80, 50]) #设定红色阈值,HSV空间 redUpper = np.array([8, 255, 220]) mybuffer = ...
  • OpenMV的色块自动追踪与云台控制(代码)   1、代码 import sensor, image, time from pid import PID from pyb import Servo #调用库 pan_servo=Servo(1) tilt_servo=Servo(2) red_threshold =...
  • (11)色块跟踪

    2021-03-12 06:05:10
    一、查看色块追踪的文件位置:在ros_simple_follower文件下的simple_followe的Launch文件 二、可调整识别色块的阈值,追踪过程中最大速度,中距值,PID参数 三、基本操作 1、小车开机,连接wifi,远程登录 ##登录...
  • 色彩识别小车,可以在手机端选定一个特定颜色的物体,小车可以跟随该颜色物体移动。资料内包含小车控制代码,手机APP安装包,演示代码,器件清单。
  • OpenMV 发送色块跟踪的坐标,Arduino 实时接收解析色块坐标值 OpenMV 发送数据相对来说比较简单,Arduino 的串口接收字符串也比较简单,有专门的字符串读取函数,Serial.readString()。但这个函数的实时性很差,有 ...
  • OpenMV色块寻找

    2021-04-05 10:19:10
    文章目录1、sensor.snapshot()拍一张照片2、image.find_lines()查找直线2、image.find_line_segments()查找线段2、image.find_blogs()查找色块3、image.find_circles()查找圆形 1、sensor.snapshot()拍一张照片 img ...
  • 匿名飞控openmv寻色块解读

    千次阅读 2019-07-26 17:31:23
    },对于这一部分代码可以先看下Openmv源码的数据打包,0x41是openmv里面数据打包时点检测特有的功能字,如果解析到数据包里面有0x41,说明下面代码要进行的是对于色块追踪而处理的代码,之后里面的都是将数据包里面...
  • openMV实现舵机定位色块STM32

    千次阅读 多人点赞 2021-04-18 09:16:12
    实验目的:本实验实现使用openMV检测前方色块,并传回色块的坐标位置给STM32,控制舵机转动来跟踪色块。 openMV部分 import sensor, image, time from pyb import UART import json red_threshold = (87, 21, 27, ...
  • OpenMV 检测色块

    千次阅读 2019-11-01 15:43:56
    # 色块监测 例子 (深绿色) import sensor , image , time # 颜色追踪的例子,一定要控制环境的光,保持光线是稳定的。 #设置绿色的阈值,括号里面的数值分别是L A B 的最大值和最小值(minL, maxL, minA,...
  • Open MV与STM32通信 寻找色块

    千次阅读 多人点赞 2020-10-07 19:58:24
    Open MV与STM32通信 寻找色块,循迹 最近在实验室准备电赛,由于电赛要用到摄像头,我便开始学习openmv,学习也有一段时间了想分享一下自己的心得,自己做了一个小车来寻找色块和循迹。 OPENMV端程序 寻找色块的...
  • 1 方案思路 颜色阈值检测 要实现的是多色检测,我选择的是黄色和红色,要通过阈值管理器先定义这俩颜色对应的阈值 yellow_threshold = (49, 100, 26, -18, 2, 72)#括号...y_stride 就是查找的色块的y方向上最小宽度的
  • 匿名飞控openmv寻色块代码分析

    千次阅读 2020-07-23 09:54:05
    void ANO_CBTracking_Task(u8 dT_ms) { //开启控制的条件,可以自己修改 //为色块追踪模式 if(opmv.mode_sta==1 && opmv_ct_sta.en) { //跟踪数据旋转解耦合 ANO_CBTracking_Decoupling(&dT_ms,IMU_ROL,IMU...
  • img = sensor.snapshot()#抓取一帧的图像并返回一个image对象 #img.find_blobs()查找图像中所有色块,并返回包含每个色块色块对象列表 for blob in img.find_blobs(thresholds, pixels_threshold=50, area_...
  • 在OPENMV官方给的例程里只有PCA9685例程,似乎作用不大,有一个实例是追小球的云台,但是他是直接用OPENMV自带...而且只要10钱左右。直接上代码。 main.py # main - By: DN36 - 周四 1月 28 2021 import sensor, im
  • ·· # 色块监测 例子 # # 这个例子展示了如何通过find_blobs()函数来查找图像中的色块 # 这个例子查找的颜色是深绿色 import sensor, image, time from pyb import UART import json # 颜色追踪的例子,一定要控制...
  • 物体追踪

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

    千次阅读 2017-10-12 04:09:18
    匹配追踪的过程已经在匹配追踪算法(MP)简介中进行了简单介绍,下面是使用Python进行图像重建的实践。MP算法Python版MP算法原理:算法假定输入信号与字典库中的原子在结构上具有一定的相关性,这种相关性通过信号与...
  • 在上一篇博客中提到了利用磁场强度推算传感器位置坐标的公式,下面就介绍怎么利用智能手机完成磁铁的追踪(任何具有磁感应器的装置均可以),这里主要是利用Android手机。   1:程序步骤: 首先将磁铁...
  • 7.1 目标追踪

    2020-05-09 11:27:38
    7.1 目标追踪(Object Tracking)概述 学习目标 目标 知道目标追踪的算法类型以及应用 知道目标追踪算法的任务类型以及挑战 应用 无 目标跟踪是计算机视觉领域的一个重要分支。...
  • 色块追踪部分: 也就是轮询的这两个任务: ANO_CBTracking_Task(20); ANO_CBTracking_Ctrl_Task(20); 1、第一个是色块追踪的数据处理: void ANO_CBTracking_Task(u8 dT_ms) { ANO_CBTracking_Decoupling(&dT...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,985
精华内容 3,994
关键字:

色块追踪