RT-Thread-基于RT-Thread VisionBoard开发板人脸识别保险箱系统RT-Thread问答社区

基于RT-Thread VisionBoard开发板人脸识别保险箱系统

发布于 2024-09-17 16:27:47 浏览：339 订阅该版

[tocm]

人脸识别保险箱系统

人脸识别别保险箱凭借其便捷性、安全性，保密性和智能化特点，在多个场景中都有广泛的应用前景。
人脸识别保险箱核心技术是人脸识别技术。该技术利用摄像头采集用户的面部图像，然后通过算法进行人脸特征提取和匹配，最终判断用户身份的合法性，并控制柜门的开启和关闭。人脸识别技术通常包括面部检测、面部对齐、特征提取和特征匹配等步骤，其中面部对齐和特征提取是最为关键的环节。
本文硬件采用RT-Thread VisionBoard 开发板 软件基于RT-Thread  rtos  和 OpenmV 实现人脸识别，包括人脸检测、特征提取和识别等，并配合Python代码示例来演示如何实现这些功能。
1.首先下载安装开发软件。
 
 
2.配置好软件包，编译后下载到开发板，并连接OPENMV软件

![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20240917/8ec6056115bb706489a55a7ffc0f9070.png.webp)

![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20240917/23d3866b2b8a4dd69a34e99abc583cb0.png.webp)

![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20240917/6dd9fcce8db805d7cb36f3ca678227af.png.webp)

![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20240917/ad6cbb947e38399010c742dcda4aec1f.png.webp)

![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20240917/b96d8223202723ad864d82a5f470343b.png.webp)

![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20240917/8f730c979b718d26a5f805a83a8e76cb.png.webp)

3.基于OpenMV的人脸识别，支持人脸注册、人脸检测、人脸识别
  VisionBoard源程序： https://gitee.com/zkarm2008/vision-board.git
  测试验证程序：
  
[face_id.py](https://club.rt-thread.org/file_download/b80a1b25c713a09c)
  
```c
# Untitled - By: xiaobo - Tue Sep 17 2024

import random

import sensor, time, image
import os, time
import machine
from machine import Pin
import time

from pyb import LED

clock = time.clock()

red = LED(1)
green = LED(2)
blue = LED(3)

PIN_KEY0 = 0x907
key_0 = Pin(("key_0", PIN_KEY0))
key_flag = 0

def func(v):
    global key_flag
    key_flag = 1

key_0.irq(trigger=Pin.IRQ_RISING, handler=func)

#sensor.reset()
#sensor.set_pixformat(sensor.RGB565)
#sensor.set_framesize(sensor.QVGA)
#sensor.skip_frames(time = 2000)

REGISTER_MODE = 0

sensor.reset()
sensor.set_contrast(1)
sensor.set_gainceiling(16)
sensor.set_framesize(sensor.HQVGA)
sensor.set_pixformat(sensor.GRAYSCALE)
sensor.skip_frames(10)

Path_Backup = {'path':'', 'id':0}
rootpath = "/orl_faces"
DIST_THRESHOLD = 15000  # 差异度阈值

def debug(strings):
    print(strings)
    usart1.write(str(strings)+"\r\n")

def find(face_cascade, img):
    objects = img.find_features(face_cascade, threshold=0.75, scale_factor=1.25)  # 人脸检测
    if objects:
        green.on()
        time.sleep(500)
        green.off()
        width_old = 0
        height_old = 0
        index = 0
        for r in objects:  # 寻找最大的face
            if r[2] > width_old and r[3] > height_old:
                width_old = r[2]
                height_old = r[3]
                index += 1
        index -= 1
        #print("index:", index)
        img.draw_rectangle(objects[index])
        d0 = img.find_lbp((0, 0, img.width(), img.height()))
        res = match(d0)
        if res != 0:
            debug(res)
            return 1

def match(d0):  # 人脸识别
    dir_lists = os.listdir(rootpath)  # 路径下文件夹
    dir_num = len(dir_lists)          # 文件夹数量
    debug("*" * 60)
    debug("Total %d Folders -> %s"%(dir_num, str(dir_lists)))

for i in range(0, dir_num):
        item_lists = os.listdir(rootpath+'/'+dir_lists[i])  # 路径下文件
        item_num = len(item_lists)                          # 文件数量
        debug("The %d Folder[%s], Total %d Files -> %s" %(i+1, dir_lists[i], item_num, str(item_lists)))

Path_Backup['path'] = rootpath+'/'+dir_lists[i]  # 马上记录当前路径
        Path_Backup['id'] = item_num                     # 马上记录当前文件数量

for j in range(0, item_num):  # 文件依次对比
            debug(">> Current File: " + item_lists[j])
            try:
                img = image.Image("/orl_faces/%s/%s" % (dir_lists[i], item_lists[j]), copy_to_fb=True)
            except Exception as e:
                debug(e)
                break
            d1 = img.find_lbp((0, 0, img.width(), img.height()))  # 提取特征值
            dist = image.match_descriptor(d0, d1)                 # 计算差异度
            debug(">> Difference Degree: " + str(dist))
            if dist < DIST_THRESHOLD:
                debug(">> ** Find It! **")
                green.on()
                time.sleep(1000)
                green.off()
                return item_lists[j]
    debug(">> ** No Match! **")
    return 0

def register(face_cascade, img):
    global REGISTER_MODE
    if find(face_cascade, img) == 1:
        debug(">> Existing without registration!")
        REGISTER_MODE = 0
        return 0

dir_lists = os.listdir(rootpath)  # 路径下文件夹
    dir_num = len(dir_lists)          # 文件夹数量
    new_dir = ("%s/%d") % (rootpath, int(dir_num)+1)
    os.mkdir(new_dir)                 # 创建文件夹
    cnt = 5  # 拍摄5次图片
    while cnt:
        img = sensor.snapshot()
        objects = img.find_features(face_cascade, threshold=0.75, scale_factor=1.25)  # 人脸检测
        if objects:
            width_old = 0
            height_old = 0
            index = 0
            for r in objects:  # 寻找最大的face
                if r[2] > width_old and r[3] > height_old:
                    width_old = r[2]
                    height_old = r[3]
                    index += 1
            index -= 1
            #print("index:", index)

item_lists = os.listdir(new_dir)  # 新路径下文件
            item_num = len(item_lists)        # 文件数量
            img.save("%s/%d.pgm" % (new_dir, item_num))  # 写入文件
            debug(">> [%d]Regist OK!" % cnt)
            img.draw_rectangle(objects[index])
            green.on()
            time.sleep(50)
            green.off()
            cnt -= 1
            if cnt==0:
                green.on()
                time.sleep(1000)
                green.off()
        REGISTER_MODE = 0

def main():
    global REGISTER_MODE
    try:
        os.mkdir(rootpath)
    except:
        pass
    #key_flag # 1为注册模式，即拍照存入
    face_cascade = image.HaarCascade("frontalface", stages=25)
    #try:
        #face_cascade = image.HaarCascade("/haarcascade_frontalcatface.cascade", stages=25)  # "frontalface"
    #except:
        #face_cascade = image.HaarCascade("frontalface", stages=25)
    print(face_cascade)
    clock = time.clock()
    img = None

while (True):
        clock.tick()
        img = sensor.snapshot()
        if key_flag == 1:
            REGISTER_MODE = 1

if REGISTER_MODE == 1:
            debug("REGISTER_MODE\r\n")
            register(face_cascade, img)
        else:
            res = find(face_cascade, img)
            if res==1:
                usart3.write("Find It\r\n")

main()

```
  
  
4.rt-thread 非常完善的软件生态和VisionBoard开发板强大的处理能力，在产品设计中非常好用。