OpenMV图像处理的方法3

模版匹配NCC

需要插上sd卡后进行下列步骤，（注意先插sd卡再上电哦）模板图片大小要超过openmv内置的flash。

1.创建或导入一个模板

注意这个模板必须得是pgm格式的，而且大小有限制，不能超过openmv的像素大小。 我们可以直接从openmv里面截取一个模板图像，可以先运行helloworld.py例程，让frambuffer显示出图像，然后进行截取。

2.转成pgm格式

选择 save image selection to pc，注意从openmv里面直接截取保存的图片是bmp格式的，我们需要把它转换成pgm格式。

可以在这个网站进行在线转换https://convertio.co/zh/bmp-pgm/ 再将转换完的pgm模板保存到sd卡中。

3.改例程中图片名

把第30行的模板文件名template.pgm改成刚刚的相应的图片名。

4.运行

注：sd卡马上到位，即将实现
例程：NCC算法

import time, sensor, image
from image import SEARCH_EX, SEARCH_DS
#从imgae模块引入SEARCH_EX和SEARCH_DS。使用from import仅仅引入SEARCH_EX, 
#SEARCH_DS两个需要的部分，而不把image模块全部引入。

# Reset sensor
sensor.reset()

# Set sensor settings
sensor.set_contrast(1)
sensor.set_gainceiling(16)
# Max resolution for template matching with SEARCH_EX is QQVGA
sensor.set_framesize(sensor.QQVGA)
# You can set windowing to reduce the search image.
#sensor.set_windowing(((640-80)//2, (480-60)//2, 80, 60))
sensor.set_pixformat(sensor.GRAYSCALE)

# Load template.
# Template should be a small (eg. 32x32 pixels) grayscale image.
template = image.Image("/template.pgm")
#加载模板图片

clock = time.clock()

# Run template matching
while (True):
    clock.tick()
    img = sensor.snapshot()
    r = img.find_template(template, 0.70, step=4, search=SEARCH_EX) #, roi=(10, 0, 60, 60))
    
    if r:
        img.draw_rectangle(r)

    print(clock.fps())

模板匹配函数find_template用法：

eg: r = img.find_template(template, 0,7, roi=(10,0,80,60), step=4, search=SEARCH_EX)
threshold中的0.7是相似度阈值,roi是进行匹配的区域（左上顶点为（10，0），长80宽60的矩形），注意roi的大小要比模板图片大，比frambuffer小。建议模版图片小于80*60。

模板匹配（find_temolate）

1.采用的是ncc算法，只能匹配与模板图片大小和角度基本一致的图案。

局限性相对来说比较大，视野中的目标图案稍微比模板图片大一些或者小一些就可能匹配不成功。

2.模板匹配适应于摄像头与目标物体之间距离确定，不需要动态移动的情况。

比如适应于流水线上特定物体的检测，而不适应于小车追踪一个运动的排球（因为运动的排球与摄像头的距离是动态的，摄像头看到的排球大小会变化，不会与模板图片完全一样）。

3.多角度多大小匹配可以尝试保存多个模板，采用多模板匹配，提前存取多个模板即可。

如下，这样就可以同时识别了。

方案一：

方案二：用for循环

特征点检测

如果是刚开始运行程序，例程提取最开始的图像作为目标物体特征，kpts1保存目标物体的特征。

默认会匹配目标特征的多种比例大小和角度，而不仅仅是保存目标特征时的大小角度，比模版匹配灵活，也不需要像多模板匹配一样保存多个模板图像。

不推荐提前保存目标特征，因为环境光线等原因的干扰，可能导致每次运行程序光线不同特征不同，匹配度会降低。
但是最新版本的固件已升级，也可以尝试提前保存目标特征。

image.find_keypoints

image.find_keypoints(roi=Auto, threshold=20, normalized=False, scale_factor=1.5, max_keypoints=100, corner_detector=CORNER_AGAST)

roi表示识别的区域，是一个元组（x,y,w,h）,默认与framsesize大小一致。

threshold是0~255的一个阈值，用来控制特征点检测的角点数量。用默认的AGAST特征点检测，这个阈值大概是20。用FAST特征点检测，这个阈值大概是60～80。设置匹配的准确度，用来过滤掉有歧义的匹配。这个值越小，准确度越高。阈值越低，获得的角点越多。

normalized是一个布尔数值，默认是False，可以匹配目标特征的多种大小（比ncc模版匹配效果灵活）。如果设置为True，关闭特征点检测的多比例结果，仅匹配目标特征的一种大小（类似于模版匹配），但是运算速度会更快一些。

scale_factor是一个大于1.0的浮点数。这个数值越高，检测速度越快，但是匹配准确率会下降。一般在1.35~1.5左右最佳。

max_keypoints是一个物体可提取的特征点的最大数量。如果一个物体的特征点太多导致RAM内存爆掉，减小这个数值。

corner_detector是特征点检测采取的算法，默认是AGAST算法。FAST算法会更快但是准确率会下降。

match.count()

match.count()是kpt1和kpt2的匹配的近似特征点数目。如果大于10，证明两个特征相似，匹配成功。

例程：利用特征点检测特定物体

向相机显示一个对象，然后运行该脚本。 一组关键点将被提取一次，然后在以下帧中进行跟踪。 如果您想要一组新的关键点，请重新运行该脚本。
注意：需调整find_keypoints和match_keypoints。

import sensor, time, image
sensor.reset()
sensor.set_contrast(3)
sensor.set_gainceiling(16)
sensor.set_framesize(sensor.VGA)
sensor.set_windowing((320, 240))
sensor.set_pixformat(sensor.GRAYSCALE)

sensor.skip_frames(time = 2000)
sensor.set_auto_gain(False, value=100)

#画出特征点
def draw_keypoints(img, kpts):
    if kpts:
        print(kpts)
        img.draw_keypoints(kpts)
        img = sensor.snapshot()
        time.sleep(1000)

kpts1 = None
#kpts1保存目标物体的特征，可以从文件导入特征，但是不建议这么做。
#kpts1 = image.load_descriptor("/desc.orb")
#img = sensor.snapshot()
#draw_keypoints(img, kpts1)

clock = time.clock()

while (True):
    clock.tick()
    img = sensor.snapshot()
    if (kpts1 == None):
        kpts1 = img.find_keypoints(max_keypoints=150, threshold=10, scale_factor=1.2)
        draw_keypoints(img, kpts1)
        #画出此时的目标特征
    else:
        #当与最开始的目标特征进行匹配时，默认设置normalized=True，只匹配目标特征的一种大小。
        # NOTE: When extracting keypoints to match the first descriptor, we use normalized=True to extract
        # keypoints from the first scale only, which will match one of the scales in the first descriptor.
        kpts2 = img.find_keypoints(max_keypoints=150, threshold=10, normalized=True)
        #如果检测到特征物体
        if (kpts2):
            #匹配当前找到的特征和最初的目标特征的相似度
            match = image.match_descriptor(kpts1, kpts2, threshold=85)
            if (match.count()>10):
                #在匹配到的目标特征中心画十字和矩形框。
                img.draw_rectangle(match.rect())
                img.draw_cross(match.cx(), match.cy(), size=10)

            #match.theta()是匹配到的特征物体相对目标物体的旋转角度。
            print(kpts2, "matched:%d dt:%d"%(match.count(), match.theta()))
    # Draw FPS
    #打印帧率。
    img.draw_string(0, 0, "FPS:%.2f"%(clock.fps()))

测距

方案1：Apriltag

利用apriltag，Apriltag可以进行3D定位，然后就是纯计算了。

方案2：参照物比例

OpenMV采用的是单目摄像头，想要实现测距，就需要选参照物，利用参照物的大小比例来计算距离。

实际长度和摄像头里的像素成反比。

简化就是，距离 = 一个常数/直径的像素
同理，实际大小=k*直径的像素

1.设置阈值

这个过程中的阈值要准确，就算是固定物体的红色，也会受光线等所干扰，如果在例程运行时没有选中目标物体，就需要再次调整阈值。
教程里的例程不是自己的，一定要改，不然怎么识别呢。

2.确定k

将目标放到20厘米处，输出像素数Lm，由k=20*Lm就可得。

3.输出距离

例程： print(length)

import sensor, image, time
yellow_threshold   = ( 56,   83,    5,   57,   63,   80)
sensor.reset() # Initialize the camera sensor.
sensor.set_pixformat(sensor.RGB565) # use RGB565.
sensor.set_framesize(sensor.QQVGA) # use QQVGA for speed.
sensor.skip_frames(10) # Let new settings take affect.
sensor.set_auto_whitebal(False) # turn this off.
clock = time.clock() # Tracks FPS.

K=5000#the value should be measured

while(True):
    clock.tick() # Track elapsed milliseconds between snapshots().
    img = sensor.snapshot() # Take a picture and return the image.

    blobs = img.find_blobs([yellow_threshold])
    if len(blobs) == 1:
        b = blobs[0] # Draw a rect around the blob.
        img.draw_rectangle(b[0:4]) # rect
        img.draw_cross(b[5], b[6]) # cx, cy
        Lm = (b[2]+b[3])/2 #长和宽得平均数
        length = K/Lm
        print(length)

4.求目标物体面积

有了便利的在指定距离检测面积大小和长宽的方法，就可以运用于流水线分合格品等，开始会有误差，在不断调整后，误差也会减小。

方案3.ToF光学测距

ToF光学测距是通过光发射回芯片的时间来测距的，可用于避障，视野要比红外窄，在近距离测距也要比红外精准。

注：Distance-Shield 距离扩展板暂无，未实现。

例程：测距

from machine import I2C
from vl53l1x import VL53L1X#引入拓展版
import time

i2c = I2C(2)
distance = VL53L1X(i2c)

while True:
    print("range: mm ", distance.read())
    time.sleep(50)

例程：简单的避障