MicroPython é uma versão leve do interpretador projetado para executar a linguagem de programação Python 3 em sistemas embarcados. Comparado com o Python normal, o interpretador MicroPython é pequeno (apenas cerca de 100 KB) e é compilado em um arquivo executável binário para execução, resultando em maior eficiência de execução. Ele usa um mecanismo leve de coleta de lixo e remove a maior parte da biblioteca padrão do Python para acomodar microcontroladores com recursos limitados.
Os principais recursos do MicroPython incluem:
1. A sintaxe e as funções são compatíveis com o Python padrão, tornando-o fácil de aprender e usar. Suporta a maior parte da sintaxe central do Python.
2. Acesse e controle diretamente o hardware, controle GPIO, I2C, SPI, etc., como Arduino.
3. Sistema de módulo poderoso, fornecendo sistema de arquivos, rede, interface gráfica e outras funções.
4. Suporta compilação cruzada para gerar código nativo eficiente, que é 10 a 100 vezes mais rápido que o intérprete.
5. A quantidade de código é pequena e o uso de memória é pequeno.É adequado para execução em MCU e placas de desenvolvimento com pouca memória.
6. Licença de código aberto, de uso gratuito. O ambiente interativo Shell oferece conveniência para desenvolvimento e teste.
7. O driver de E/S integrado suporta um grande número de plataformas de microcontroladores, como ESP8266, ESP32, STM32, micro:bit, placa de controle e PyBoard, etc. Existe uma comunidade ativa.
Os cenários de aplicação MicroPython incluem:
1. Construir rapidamente protótipos e interações de usuário para produtos incorporados.
2. Faça alguns pequenos projetos de hardware programável.
3. Como ferramenta educacional, ajuda os iniciantes a aprender programação Python e IoT.
4. Crie firmware de dispositivo inteligente para obter controle avançado e conectividade em nuvem.
5. Várias aplicações de microcontroladores, como Internet das Coisas, inteligência incorporada, robôs, etc.
Coisas a serem observadas ao usar MicroPython:
1. A memória e o espaço Flash são limitados.
2. A explicação e a eficiência de execução não são tão boas quanto a linguagem C.
3. Algumas funções da biblioteca são diferentes da versão padrão.
4. Otimize a sintaxe da plataforma e corrija as diferenças com o Python padrão.
5. Use os recursos de memória de forma racional e evite alocar grandes blocos de memória com frequência.
6. Use código nativo para melhorar o desempenho de peças críticas de velocidade.
7. Use a abstração apropriadamente para encapsular as operações de hardware subjacentes.
De modo geral, o MicroPython traz o Python para o campo dos microcontroladores, o que é uma inovação importante que não apenas reduz o limite de programação, mas também fornece bons recursos de controle de hardware. É muito adequado para o desenvolvimento de vários tipos de Internet das Coisas e hardware inteligente.
OpenMV Cam é uma placa microcontroladora pequena e de baixo consumo de energia que permite implementar facilmente aplicações usando visão de máquina no mundo real. Você pode programar OpenMV Cam usando scripts Python de alto nível (fornecidos pelo MicroPython OS) em vez de C/C++. Os parâmetros técnicos do OpenMV Cam incluem os seguintes aspectos:
1. Processador: OpenMV Cam H7 Plus usa processador STM32H743II ARM Cortex M7, rodando a 480 MHz, com 32 MB SDRAM + 1 MB SRAM e 32 MB de memória flash externa + 2 MB de memória flash interna. OpenMV Cam M4 V2 usa processador STM32F427VG ARM Cortex M4 rodando a 180 MHz com 256 KB de RAM e 1 MB de memória flash.
2. Sensor de imagem: Tanto o OpenMV Cam H7 Plus quanto o OpenMV Cam M4 V2 usam o sensor de imagem OV7725, que pode capturar imagens em escala de cinza 320x240 de 8 bits ou imagens RGB565 de 16 bits 320x240 a 75 FPS em resoluções superiores a 320x240. 150 FPS em 320x240.
3. Interface de E/S: OpenMV Cam H7 Plus e OpenMV Cam M4 V2 possuem as seguintes interfaces de E/S:
(1) Interface USB de velocidade total (12Mbs), conectada ao computador. Quando a OpenMV Cam estiver conectada, uma porta COM virtual e uma “unidade flash USB” aparecerão no seu computador.
(2) O slot para cartão μSD é capaz de leitura/gravação de 100 Mbs, permitindo que sua câmera OpenMV grave vídeo e extraia material de visão de máquina do cartão μSD.
(3) O barramento SPI opera a uma velocidade de até 54 Mbs, permitindo simplesmente transmitir dados de fluxo de imagem para a placa de expansão LCD, placa de expansão WiFi ou outros controladores.
(4) Barramento I2C (até 1Mb/s), barramento CAN (até 1Mb/s) e barramento serial assíncrono (TX/RX, até 7,5Mb/s) para conexão com outros controladores ou sensores.
(5) Um ADC de 12 bits e um DAC de 12 bits.
(6) Existem interrupções e PWM em todos os pinos de E/S (existem 9 ou 10 pinos de E/S na placa).
4. LED: Tanto o OpenMV Cam H7 Plus quanto o OpenMV Cam M4 V2 são equipados com um LED RGB (tricolor) e dois LEDs IR brilhantes de 850 nm (infravermelho).
5. Lente: Tanto o OpenMV Cam H7 Plus quanto o OpenMV Cam M4 V2 são equipados com uma interface de lente M12 padrão e uma lente padrão de 2,8 mm. Se quiser usar uma lente mais profissional com sua OpenMV Cam, você pode comprá-la facilmente e instalá-la você mesmo.
O OpenMV Cam do MicroPython suporta a função de reconhecimento facial e pode detectar e reconhecer rostos escrevendo código MicroPython. A seguir explicarei detalhadamente suas principais características, cenários de aplicação e assuntos que necessitam de atenção.
Característica principal:
Detecção de rosto: o recurso de reconhecimento de rosto do OpenMV Cam pode detectar rostos em imagens em tempo real. Ele usa algoritmos de processamento de imagem e tecnologia de aprendizado de máquina para detectar e localizar rostos, realizando assim o reconhecimento e rastreamento facial.
Extração de características faciais: além de detectar rostos, o OpenMV Cam também pode extrair informações de características de rostos. Através da extração de características, o rosto pode ser representado como um vetor digital para tarefas subsequentes, como reconhecimento, comparação e verificação.
Desempenho em tempo real: OpenMV Cam possui alto desempenho em tempo real e pode capturar imagens e realizar reconhecimento facial em tempo real. Isso o torna adequado para cenários de aplicação que exigem resposta rápida e processamento em tempo real, como sistemas de controle de acesso presencial, pagamento presencial, etc.
Desenvolvimento simplificado: A linguagem de programação MicroPython é fácil de aprender e adequada para iniciantes e áreas educacionais. OpenMV Cam fornece uma interface de programação amigável e código de amostra, tornando o desenvolvimento e a depuração do reconhecimento facial mais fácil e conveniente.
Cenários de aplicação:
Sistema de controle de acesso facial: O reconhecimento facial pode ser aplicado a sistemas de controle de acesso para obter autorização e controle de acesso a áreas ou dispositivos específicos, identificando e verificando informações faciais. Por exemplo, o controle de acesso ou o equipamento de controle só podem ser desbloqueados se as informações faciais pré-registradas forem correspondidas com sucesso.
Pagamento facial: Em sistemas de pagamento, o reconhecimento facial pode ser usado para verificação de identidade e autorização de transações. Os usuários podem confirmar sua identidade por meio de digitalização facial, possibilitando operações de pagamento sem senhas ou cartões, melhorando a comodidade e segurança do pagamento.
Pesquisa e educação de reconhecimento facial: A função de reconhecimento facial do OpenMV Cam pode ser usada em projetos de ensino e pesquisa científica. Estudantes e pesquisadores podem usar o OpenMV Cam para realizar experimentos e pesquisas, explorando conhecimentos em algoritmos de reconhecimento facial, análise de expressões faciais e outras áreas relacionadas.
Coisas a serem observadas:
Iluminação e ângulo facial: o reconhecimento facial é sensível à iluminação e ao ângulo facial. Para obter resultados de reconhecimento precisos, você precisa prestar atenção para fornecer iluminação suficiente e tentar manter o ângulo normal do rosto dentro do campo de visão da câmera.
Oclusões e alterações faciais: Oclusões faciais (como máscaras, óculos de sol) ou alterações nas expressões faciais (como sorrir, abrir a boca) podem afetar o efeito de reconhecimento. Em aplicações práticas, é necessário selecionar algoritmos de reconhecimento facial apropriados e configurações de parâmetros com base em cenários e necessidades específicas para lidar com os desafios causados pela oclusão e alterações faciais.
Privacidade e segurança de dados: O reconhecimento facial envolve questões de privacidade pessoal e segurança de dados. Ao aplicar a tecnologia de reconhecimento facial, você precisa cumprir as leis, regulamentos e políticas de privacidade relevantes para garantir a segurança e o uso legal dos dados pessoais.
Em resumo, a função de reconhecimento facial do OpenMV Cam do MicroPython pode realizar detecção facial, reconhecimento e extração de recursos, com alto desempenho em tempo real e recursos de desenvolvimento simplificados. É adequado para sistemas de controle de acesso presencial, pagamento presencial, educação e pesquisa e outros cenários de aplicação. Ao usar, você precisa prestar atenção a fatores como iluminação facial, ângulos e oclusão, e cumprir os regulamentos relevantes de privacidade e segurança.
Caso 1: Usando OpenMV Cam para detecção de rosto
import sensor, image, time
from pyb import Timer, ADC
sensor.reset() # 初始化摄像头
sensor.set_pixformat(sensor.RGB565) # 设置像素格式为RGB565
sensor.set_framesize(sensor.QVGA) # 设置帧大小为320x240
sensor.skip_frames(time = 2000) # 等待设置生效，延时2秒
timer = Timer(period=1, mode=Timer.PERIODIC, callback=lambda t: None) # 创建一个定时器，每1毫秒触发一次回调函数
while True:
img = sensor.snapshot() # 捕获一帧图像
faces = img.find_features(image.HaarCascade("haarcascade_frontalface_default.xml")) # 使用Haar级联分类器检测人脸
for face in faces:
img.draw_rectangle(face.rect(), color=(255, 0, 0)) # 在图像上绘制矩形框，颜色为红色
print("Found", len(faces), "faces") # 输出检测到的人脸数量
time.sleep_ms(100) # 延时100毫秒
Interpretação: Este programa importa primeiro os módulos sensor, imagem, tempo e pyb.Timer, pyb.ADC. Em seguida, inicialize a câmera, defina o formato do pixel para RGB565, o tamanho do quadro para 320x240 e aguarde as configurações entrarem em vigor, com um atraso de 2 segundos. Em seguida, crie um cronômetro para acionar a função de retorno de chamada a cada 1 milissegundo. Num loop infinito, as imagens da câmera são capturadas continuamente. Use o classificador em cascata Haar para detectar rostos e desenhar caixas retangulares na imagem. Finalmente, o número de rostos detectados é gerado e atrasado em 100 milissegundos.
Caso 2: Usando OpenMV Cam para reconhecimento facial
import sensor, image, time
from pyb import Timer, ADC
sensor.reset() # 初始化摄像头
sensor.set_pixformat(sensor.RGB565) # 设置像素格式为RGB565
sensor.set_framesize(sensor.QVGA) # 设置帧大小为320x240
sensor.skip_frames(time = 2000) # 等待设置生效，延时2秒
timer = Timer(period=1, mode=Timer.PERIODIC, callback=lambda t: None) # 创建一个定时器，每1毫秒触发一次回调函数
face_recognition = Timer(period=1, mode=Timer.PERIODIC, callback=lambda t: None) # 创建一个定时器，每1毫秒触发一次回调函数
face_recognition.start() # 开始人脸识别计时器
while True:
img = sensor.snapshot() # 捕获一帧图像
faces = img.find_features(image.HaarCascade("haarcascade_frontalface_default.xml")) # 使用Haar级联分类器检测人脸
if len(faces) > 0:
face = faces[0] # 获取第一个检测到的人脸
x, y, w, h = face.rect() # 获取人脸矩形框的坐标和宽高
img.draw_rectangle(x, y, w, h, color=(255, 0, 0)) # 在图像上绘制矩形框，颜色为红色
face_id = face.feature_id() # 获取人脸的特征ID
if face_id not in known_faces: # 如果特征ID不在已知人脸列表中
face_recognition.stop() # 停止人脸识别计时器
known_faces.append(face_id) # 将特征ID添加到已知人脸列表中
face_recognition.start() # 重新开始人脸识别计时器
else:
face_recognition.stop() # 停止人脸识别计时器
time.sleep_ms(100) # 延时100毫秒
print("Found", len(known_faces), "known faces") # 输出已知人脸数量
time.sleep_ms(100) # 延时100毫秒
Interpretação: Este programa é semelhante ao primeiro caso, exceto que a função de reconhecimento facial foi adicionada. Primeiramente foram importados os módulos sensor, imagem, tempo e pyb.Timer, pyb.ADC. Em seguida, inicialize a câmera, defina o formato do pixel para RGB565, o tamanho do quadro para 320x240 e aguarde as configurações entrarem em vigor, com um atraso de 2 segundos. Em seguida, crie um cronômetro para acionar a função de retorno de chamada a cada 1 milissegundo. Num loop infinito, as imagens da câmera são capturadas continuamente. Use o classificador em cascata Haar para detectar rostos e desenhar caixas retangulares na imagem. Se um rosto for detectado, obtenha seu ID de recurso e adicione-o à lista de rostos conhecidos. Em seguida, reinicie o temporizador de reconhecimento facial. Finalmente, o número de faces conhecidas é gerado e atrasado em 100 milissegundos.
Caso 3: Usando OpenMV Cam para reconhecimento facial (versão atualizada)
import sensor, image, time
from pyb import Timer, ADC
sensor.reset() # 初始化摄像头
sensor.set_pixformat(sensor.RGB565) # 设置像素格式为RGB565
sensor.set_framesize(sensor.QVGA) # 设置帧大小为320x240
sensor.skip_frames(time = 2000) # 等待设置生效，延时2秒
timer = Timer(period=1, mode=Timer.PERIODIC, callback=lambda t: None) # 创建一个定时器，每1毫秒触发一次回调函数
face_recognition = Timer(period=1, mode=Timer.PERIODIC, callback=lambda t: None) # 创建一个定时器，每1毫秒触发一次回调函数
face_recognition_threshold = 0.6 # 人脸识别阈值
face_recognition.start() # 开始人脸识别计时器
known_faces = [] # 已知人脸列表
while True:
img = sensor.snapshot() # 捕获一帧图像
faces = img.find_features(image.HaarCascade("haarcascade_frontalface_default.xml")) # 使用Haar级联分类器检测人脸
if len(faces) > 0:
face = faces[0] # 获取第一个检测到的人脸
x, y, w, h = face.rect() # 获取人脸矩形框的坐标和宽高
img.draw_rectangle(x, y, w, h, color=(255, 0, 0)) # 在图像上绘制矩形框，颜色为红色
face_id = face.feature_id() # 获取人脸的特征ID
if face_id not in known_faces and face_recognition.is_running(): # 如果特征ID不在已知人脸列表中且人脸识别计时器正在运行
# 计算人脸区域的平均亮度
face_region = img.crop((x, y, x+w, y+h)) # 截取人脸区域
avg_brightness = (sum(c for c in face_region.pixels()) / face_region.width * face_region.height) / 255 # 计算平均亮度
if avg_brightness > face_recognition_threshold: # 如果平均亮度大于阈值
face_recognition.stop() # 停止人脸识别计时器
known_faces.append(face_id) # 将特征ID添加到已知人脸列表中
face_recognition.start() # 重新开始人脸识别计时器
else:
face_recognition.stop() # 停止人脸识别计时器
time.sleep_ms(100) # 延时100毫秒
print("Found", len(known_faces), "known faces") # 输出已知人脸数量
time.sleep_ms(100) # 延时100毫秒
Interpretação: Este programa é semelhante ao segundo caso, exceto que a função de reconhecimento facial foi adicionada. Primeiramente foram importados os módulos sensor, imagem, tempo e pyb.Timer, pyb.ADC. Em seguida, inicialize a câmera, defina o formato do pixel para RGB565, o tamanho do quadro para 320x240 e aguarde as configurações entrarem em vigor, com um atraso de 2 segundos. Em seguida, crie um cronômetro para acionar a função de retorno de chamada a cada 1 milissegundo. Num loop infinito, as imagens da câmera são capturadas continuamente. Use o classificador em cascata Haar para detectar rostos e desenhar caixas retangulares na imagem. Se um rosto for detectado, obtenha seu ID de recurso e determine se deseja adicioná-lo à lista de rostos conhecidos com base no limite de reconhecimento facial. Em seguida, reinicie o temporizador de reconhecimento facial. Finalmente, o número de faces conhecidas é gerado e atrasado em 100 milissegundos.
Caso 4: Programa simples de reconhecimento facial
import sensor, image, time
sensor.reset() # 初始化摄像头
sensor.set_pixformat(sensor.RGB565) # 设置像素格式
sensor.set_framesize(sensor.QVGA) # 设置帧大小
sensor.skip_frames(time = 2000) # 等待摄像头稳定
face_cascade = image.HaarCascade('haarcascade_frontalface_default.xml') # 加载人脸级联分类器
while(True):
img = sensor.snapshot() # 拍摄照片
faces = img.find_haarcascades(face_cascade) # 查找人脸
if len(faces) > 0: # 如果找到了人脸
print('Face detected') # 打印消息
Pontos-chave para interpretar:
Primeiro inicialize a câmera e defina o formato do pixel e o tamanho do quadro.
Carregue o classificador em cascata de faces. O classificador em cascata de faces fornecido pelo OpenCV é usado aqui.
Num loop infinito, tire fotos e encontre rostos. Se um rosto for encontrado, uma mensagem será impressa. Use a função find_haarcascades() para encontrar rostos.
Caso 5: Exibir resultados de reconhecimento facial na tela LCD
import sensor, image, time, lcd
lcd.init() # 初始化LCD屏幕
sensor.reset() # 初始化摄像头
sensor.set_pixformat(sensor.RGB565) # 设置像素格式
sensor.set_framesize(sensor.QVGA) # 设置帧大小
sensor.skip_frames(time = 2000) # 等待摄像头稳定
face_cascade = image.HaarCascade('haarcascade_frontalface_default.xml') # 加载人脸级联分类器
while(True):
img = sensor.snapshot() # 拍摄照片
faces = img.find_haarcascades(face_cascade) # 查找人脸
if len(faces) > 0: # 如果找到了人脸
lcd.clear() # 清空LCD屏幕
for face in faces: # 在LCD屏幕上绘制人脸矩形框
lcd.draw_rectangle(face.rect(), lcd.COLOR_RED)
Interpretação dos pontos-chave:
Primeiro inicialize a tela LCD e a câmera, defina o formato do pixel e o tamanho do quadro.
Carregue o classificador em cascata de faces. O classificador em cascata de faces fornecido pelo OpenCV é usado aqui.
Num loop infinito, tire fotos e encontre rostos. Se um rosto for encontrado, a tela LCD será apagada e uma moldura retangular do rosto será desenhada nela. Use a função draw_rectangle() para desenhar uma caixa retangular.
Caso 6: Usando reconhecimento facial para controlar o movimento do robô
import sensor, image, time, pyb, machine
motor1 = machine.PWM(pyb.Pin('X1'), freq=100) # 初始化电机1引脚为PWM输出，频率为100Hz
motor2 = machine.PWM(pyb.Pin('X2'), freq=100) # 初始化电机2引脚为PWM输出，频率为100Hz
sensor.reset() # 初始化摄像头
sensor.set_pixformat(sensor.RGB565) # 设置像素格式
sensor.set_framesize(sensor.QVGA) # 设置帧大小
sensor.skip_frames(time = 2000) # 等待摄像头稳定
face_cascade = image.HaarCascade('haarcascade_frontalface_default.xml') # 加载人脸级联分类器
speed = 1000 # 设置电机速度，这里是1000（占空比）
while(True):
img = sensor.snapshot() # 拍摄照片
faces = img.find_haarcascades(face_cascade) # 查找人脸
if len(faces) > 0: # 如果找到了人脸
x, y = faces[0].center() # 获取人脸中心坐标
if x < img.width() / 2: # 如果人脸在图像左半部分
motor1.duty(speed) # 左电机前进
motor2.duty(0) # 右电机停止
else: # 如果人脸在图像右半部分
motor1.duty(0) # 左电机停止
motor2.duty(speed) # 右电机前进
else: # 如果没有找到人脸
motor1.duty(0) # 左电机停止
motor2.duty(0) # 右电机停止
time.sleep(100) # 延时100ms，以减少CPU的使用率
Interpretação dos pontos-chave:
Primeiro inicialize o pino do motor na saída PWM e defina a frequência para 100Hz. Inicialize a câmera e defina o formato do pixel e o tamanho do quadro. Carregue o classificador em cascata de faces. O classificador em cascata de faces fornecido pelo OpenCV é usado aqui. Defina a velocidade do motor, aqui é 1000 (ciclo de trabalho).
Num loop infinito, tire fotos e encontre rostos. Se uma face for encontrada, o motor será controlado para avançar ou parar com base na posição da face. Se nenhuma face for encontrada, ambos os motores param. Use a função duty() para definir o ciclo de trabalho do motor.
Use a função time.sleep() para atrasar 100 ms para reduzir o uso da CPU.
Caso 7: Detectar e desenhar caixas delimitadoras de faces:
import sensor
import image
import time
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)
face_cascade = image.HaarCascade("frontalface.xml")
while True:
img = sensor.snapshot()
faces = img.find_features(face_cascade, threshold=0.5, scale=1.5)
for face in faces:
img.draw_rectangle(face)
time.sleep(100)
Interpretação de pontos-chave:
Este programa realiza reconhecimento facial através do OpenMV Cam e desenha caixas delimitadoras quando um rosto é detectado.
Use sensor.reset() para redefinir as configurações do sensor.
Defina o formato da imagem, o tamanho do quadro e desative o ganho automático e o equilíbrio de branco automático.
Use image.HaarCascade("frontalface.xml") para instanciar um objeto HaarCascade para detecção de rosto. O arquivo "frontalface.xml" precisa ser colocado na OpenMV Cam.
Em um loop infinito, faça com que o programa continue fazendo o seguinte:
Use sensor.snapshot() para tirar um instantâneo da imagem.
Use img.find_features(face_cascade, limiar=0.5, escala=1.5) para detectar rostos na imagem. Os parâmetros de limite e escala podem ser ajustados para obter melhores resultados de detecção de rosto.
Para cada rosto detectado, use img.draw_rectangle(face) para desenhar uma caixa delimitadora retangular na imagem.
Use time.sleep(100) para atrasar 100 milissegundos para controlar a frequência de processamento.
Caso 8: Reconhecimento facial e resultados de reconhecimento de saída:
import sensor
import image
import time
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)
face_cascade = image.HaarCascade("frontalface.xml")
known_face_image = image.Image("/known_face.jpg")
known_face_descriptor = image.vector_descriptor(known_face_image)
while True:
img = sensor.snapshot()
faces = img.find_features(face_cascade, threshold=0.5, scale=1.5)
for face in faces:
descriptor = img.get_descriptor(face)
match = image.match_descriptor(known_face_descriptor, descriptor, threshold=85)
if match:
print("Recognized face!")
else:
print("Unknown face!")
time.sleep(100)
Interpretação de pontos-chave:
Este programa realiza o reconhecimento facial por meio do OpenMV Cam e gera os resultados do reconhecimento com base em imagens faciais conhecidas.
Use sensor.reset() para redefinir as configurações do sensor.
Defina o formato da imagem, o tamanho do quadro e desative o ganho automático e o equilíbrio de branco automático.
Use image.HaarCascade("frontalface.xml") para instanciar um objeto HaarCascade para detecção de rosto. O arquivo "frontalface.xml" precisa ser colocado na OpenMV Cam.
Use image.Image("/known_face.jpg") para carregar uma imagem de rosto conhecida e convertê-la em um descritor de recurso.
Em um loop infinito, faça com que o programa continue fazendo o seguinte:
Use sensor.snapshot() para tirar um instantâneo da imagem.
Use img.find_features(face_cascade, limiar=0.5, escala=1.5) para detectar rostos na imagem.
Para cada rosto detectado, use img.get_descriptor(face) para obter o descritor de recurso do rosto.
Use image.match_descriptor(known_face_descriptor, descriptor, limiar=85) para combinar o descritor de recurso facial detectado com o descritor de recurso facial conhecido e defina o limite de correspondência como 85.
Dependendo do resultado correspondente, use print() para gerar “Rosto reconhecido!” ou “Rosto desconhecido!”.
Caso 9: Resultados de reconhecimento e identificação facial:
import sensor
import image
import time
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)
face_cascade = image.HaarCascade("frontalface.xml")
known_face_image = image.Image("/known_face.jpg")
known_face_descriptor = image.vector_descriptor(known_face_image)
tag_color = (0, 255, 0) # 识别结果标签的颜色
while True:
img = sensor.snapshot()
faces = img.find_features(face_cascade, threshold=0.5, scale=1.5)
for face in faces:
descriptor = img.get_descriptor(face)
match = image.match_descriptor(known_face_descriptor, descriptor, threshold=85)
if match:
img.draw_string(face[0], face[1], "Recognized", color=tag_color)
else:
img.draw_string(face[0], face[1], "Unknown", color=tag_color)
time.sleep(100)
Interpretação de pontos-chave:
Este programa realiza o reconhecimento facial através do OpenMV Cam e marca os resultados do reconhecimento na imagem.
Use sensor.reset() para redefinir as configurações do sensor.
Defina o formato da imagem, o tamanho do quadro e desative o ganho automático e o equilíbrio de branco automático.
Use image.HaarCascade("frontalface.xml") para instanciar um objeto HaarCascade para detecção de rosto. O arquivo "frontalface.xml" precisa ser colocado na OpenMV Cam.
Use image.Image("/known_face.jpg") para carregar uma imagem de rosto conhecida e convertê-la em um descritor de recurso.
Defina a cor da etiqueta.
Em um loop infinito, faça com que o programa continue fazendo o seguinte:
Use sensor.snapshot() para tirar um instantâneo da imagem.
Use img.find_features(face_cascade, limiar=0.5, escala=1.5) para detectar rostos na imagem.
Para cada rosto detectado, use img.get_descriptor(face) para obter o descritor de recurso do rosto.
Use image.match_descriptor(known_face_descriptor, descriptor, limiar=85) para combinar o descritor de recurso facial detectado com o descritor de recurso facial conhecido e defina o limite de correspondência como 85.
Dependendo do resultado correspondente, use img.draw_string() para identificar o resultado do reconhecimento ("Reconhecido" ou "Desconhecido") na imagem.
Use time.sleep(100) para atrasar 100 milissegundos para controlar a frequência de processamento.
Estes exemplos práticos de aplicação mostram como usar o OpenMV Cam para reconhecimento facial. O primeiro exemplo demonstra como detectar e desenhar caixas delimitadoras para rostos usando o objeto HaarCascade para detecção de rosto e desenhar caixas delimitadoras em uma imagem. O segundo exemplo mostra como realizar o reconhecimento facial e gerar os resultados do reconhecimento convertendo imagens faciais conhecidas em descritores de recursos, combinando os descritores de recursos faciais detectados com eles e gerando os resultados de reconhecimento correspondentes. O terceiro exemplo demonstra como realizar o reconhecimento facial e identificar os resultados do reconhecimento usando um rótulo de string na imagem para identificar os resultados do reconhecimento.
Observe que os casos acima são apenas para expansão de ideias e podem conter erros ou inaplicabilidade. Diferentes plataformas de hardware, cenários de uso e versões do MicroPython podem levar a diferentes métodos de uso. Na programação real, você precisa ajustá-la de acordo com a configuração do hardware e necessidades específicas e realizar vários testes reais. É importante garantir que o hardware esteja conectado corretamente e compreender as especificações e características dos sensores e dispositivos utilizados.
