嘉楠K230AI开发板测评8--人脸3D网络、人体关键点、车牌识别、字符识别、物体识别

dfjs 发表于 2024-11-15 22:39

本帖最后由 dfjs 于 2024-11-15 22:43 编辑

嘉楠科K230AI开发板测评8--AI视觉篇

    观察K230文件系统，AI视觉开发框架主要API接口代码位于“\CanMV\sdcard\app\libs”目录下，如下图：

    PineLine :用于采集图像、画图以及结果图片显示的API接口。

    Ai2d : 预处理（Preprocess）相关接口。

    AIBase : 模型推理主要接口。

 

    同时可以看到官方训练好的模型（后缀为.kmodel）位于“\CanMV\sdcard\app\tests\kmodel”目录下，包括人脸相关模型、人体相关模型、手部相关模型、车牌相关模型、字符识别模型、物体检测模型等，当然，也可以将自己训练的模型放在该目录下调用，如下图：

  

    同时为了下面更好的学习，在这里我搜索了目标检测算法常用的三个重要的概念:置信度阈值(Confidence Threshold）、非极大值抑制阈值（NMS）和锚点数据（Anchors），置信度阈值用于过滤检测结果，NMS阈值用于去除重叠的检测框，而锚点数据则是模型预测目标位置的基础。这三个参数共同作用，使得目标检测算法能够准确地识别和定位目标。它们在检测过程中起到关键作用，在后面的推理过程经常用到。

    置信度阈值(Confidence Threshold）：

    含义：置信度阈值用于过滤模型输出的检测结果。在目标检测模型中，模型会为每个目标输出一个置信度分数，表示模型认为检测到的目标属于某个类别的确定程度。

    作用：置信度阈值用于确定一个检测结果是否足够可靠。只有当检测结果的置信度分数高于这个阈值时，该结果才会被认为是有效的检测。低于阈值的结果将被忽略。这有助于减少误检和提高检测的准确性。

    非极大值抑制阈值（NMS）：

    含义：非极大值抑制是一种常用的技术，用于在目标检测中去除重叠的检测框。在实际场景中，同一个目标可能被模型多次检测到，产生多个边界框。NMS通过合并重叠的边界框来解决这个问题。

    作用：NMS阈值决定了两个检测框需要有多大的重叠（通常是通过交并比IoU来衡量）才会被认为是同一个目标。如果两个检测框的IoU高于NMS阈值，那么置信度较低的检测框将被抑制（即删除），只保留置信度最高的那个。这有助于减少冗余的检测结果，提高检测的精确度。

    锚点数据（Anchors）：

    含义：锚点（也称为先验框）是目标检测算法中用于预测目标位置的一种技术。锚点是一组预定义的边界框，它们有不同的尺寸和比例，用于覆盖目标可能出现的各种尺寸。

    作用：在基于锚点的目标检测算法（如Faster R-CNN、SSD等）中，模型会预测每个锚点的偏移量，以调整锚点的位置和尺寸，使其更准确地匹配目标。锚点数据包含了这些预定义边界框的坐标和尺寸，它们是模型预测的基础。

1、人脸相关

    人脸3D网格，在检测到人脸后用多个点描绘整个脸，从而把人脸轮廓像网格一样描绘出来，支持单个和多个人脸。

    通过CanMV K230 AI视觉框架开发，用到的模型已经存放在CanMV K230的文件系统，具体编程思路如下：

  

    自定义人脸检测人物类、人脸网络任务类、人脸网络后处理任务类、3D人脸网络类。

<h3>    人脸检测任务类（FaceDetApp）：</h3>

    作用：

        负责执行人脸检测任务。

    功能：

        加载人脸检测模型。

        配置图像预处理操作，如填充（pad）和缩放（resize）。

        执行模型推理。

        进行后处理，包括置信度过滤和非极大值抑制（NMS）。

    人脸网格任务类（FaceMeshApp）

    作用：

        负责执行人脸网格估计任务。

    功能：

        加载人脸网格模型。

        配置图像预处理操作，如裁剪（crop）和缩放（resize）。

        执行模型推理。

        后处理，将模型输出的参数映射回人脸网格的参数。

    人脸网格后处理任务类（FaceMeshPostApp）

    作用：

        负责对人脸网格估计的结果进行后处理。

    功能：

        接收人脸网格模型的输出参数。

        将参数转换为最终的人脸网格。

        调用aidemo库的接口进行进一步的后处理，如人脸网格的绘制。

<h3>   3D人脸网格类（FaceMesh）</h3>

    作用：

        整合人脸检测、人脸网格估计和后处理流程。

    功能：

        初始化人脸检测、人脸网格和人脸网格后处理的实例。

        运行整个3D人脸网格流程，包括人脸检测、人脸网格估计和后处理。

        绘制最终的3D人脸网格结果。

    主函数思路：

    初始化显示模式和分辨率：根据平台选择HDMI或LCD模式，并设置相应的分辨率。

    设置模型路径和其他参数：指定人脸检测、人脸网格和人脸网格后处理模型的路径，以及其他参数如锚点数据、输入分辨率等。

    初始化PipeLine：创建一个图像处理流程的实例，设置传给AI的图像分辨率和显示分辨率。

    创建3D人脸网格实例：初始化FaceMesh类，传入所需的模型路径和参数。

    主循环：

        获取当前帧图像。

        调用FaceMesh类的run方法进行人脸检测、人脸网格估计和后处理。

        打印检测和网格估计的结果。

        调用FaceMesh类的draw_result方法绘制3D人脸网格结果。

        显示推理效果。

        进行垃圾回收。

        打印帧率信息。

        异常处理：捕获并打印异常信息。

        资源清理：在finally块中释放资源，包括反初始化人脸检测、人脸网格和人脸网格后处理实例，以及销毁PipeLine实例。

    参考代码如下：

<pre>
<code class="language-python">'''
实验名称：人脸3D网格
实验平台：01Studio CanMV K230
教程：wiki.01studio.cc
'''

from libs.PipeLine import PipeLine, ScopedTiming
from libs.AIBase import AIBase
from libs.AI2D import Ai2d
import os
import ujson
from media.media import *
from time import *
import nncase_runtime as nn
import ulab.numpy as np
import time
import image
import aidemo
import random
import gc
import sys

# 自定义人脸检测任务类
class FaceDetApp(AIBase):
def __init__(self,kmodel_path,model_input_size,anchors,confidence_threshold=0.25,nms_threshold=0.3,rgb888p_size=,display_size=,debug_mode=0):
 super().__init__(kmodel_path,model_input_size,rgb888p_size,debug_mode)
 # kmodel路径
 self.kmodel_path=kmodel_path
 # 检测模型输入分辨率
 self.model_input_size=model_input_size
 # 置信度阈值
 self.confidence_threshold=confidence_threshold
 # nms阈值
 self.nms_threshold=nms_threshold
 # 检测任务锚框
 self.anchors=anchors
 # sensor给到AI的图像分辨率，宽16字节对齐
 self.rgb888p_size=,16),rgb888p_size]
 # 视频输出VO分辨率，宽16字节对齐
 self.display_size=,16),display_size]
 # debug模式
 self.debug_mode=debug_mode
 # 实例化Ai2d，用于实现模型预处理
 self.ai2d=Ai2d(debug_mode)
 # 设置Ai2d的输入输出格式和类型
 self.ai2d.set_ai2d_dtype(nn.ai2d_format.NCHW_FMT,nn.ai2d_format.NCHW_FMT,np.uint8, np.uint8)

# 配置预处理操作，这里使用了pad和resize，Ai2d支持crop/shift/pad/resize/affine，具体代码请打开/sdcard/app/libs/AI2D.py查看
def config_preprocess(self,input_image_size=None):
 with ScopedTiming("set preprocess config",self.debug_mode > 0):
 # 初始化ai2d预处理配置，默认为sensor给到AI的尺寸，可以通过设置input_image_size自行修改输入尺寸
 ai2d_input_size=input_image_size if input_image_size else self.rgb888p_size
 # 设置padding预处理
 self.ai2d.pad(self.get_pad_param(), 0, )
 # 设置resize预处理
 self.ai2d.resize(nn.interp_method.tf_bilinear, nn.interp_mode.half_pixel)
 # 构建预处理流程,参数为预处理输入tensor的shape和预处理输出的tensor的shape
 self.ai2d.build(,ai2d_input_size],,self.model_input_size])

# 自定义后处理，results是模型推理输出的array列表，这里使用了aidemo库的face_det_post_process接口
def postprocess(self,results):
 with ScopedTiming("postprocess",self.debug_mode > 0):
 res = aidemo.face_det_post_process(self.confidence_threshold,self.nms_threshold,self.model_input_size,self.anchors,self.rgb888p_size,results)
 if len(res)==0:
 return res
 else:
 return res

# padding参数计算
def get_pad_param(self):
 dst_w = self.model_input_size
 dst_h = self.model_input_size
 # 计算最小的缩放比例，等比例缩放
 ratio_w = dst_w / self.rgb888p_size
 ratio_h = dst_h / self.rgb888p_size
 if ratio_w < ratio_h:
 ratio = ratio_w
 else:
 ratio = ratio_h
 new_w = (int)(ratio * self.rgb888p_size)
 new_h = (int)(ratio * self.rgb888p_size)
 dw = (dst_w - new_w) / 2
 dh = (dst_h - new_h) / 2
 top = (int)(round(0))
 bottom = (int)(round(dh * 2 + 0.1))
 left = (int)(round(0))
 right = (int)(round(dw * 2 - 0.1))
 return

# 自定义人脸网格任务类
class FaceMeshApp(AIBase):
def __init__(self,kmodel_path,model_input_size,rgb888p_size=,display_size=,debug_mode=0):
 super().__init__(kmodel_path,model_input_size,rgb888p_size,debug_mode)
 # kmodel路径
 self.kmodel_path=kmodel_path
 # 人脸网格模型输入分辨率
 self.model_input_size=model_input_size
 # sensor给到AI的图像分辨率，宽16字节对齐
 self.rgb888p_size=,16),rgb888p_size]
 # 视频输出VO分辨率，宽16字节对齐
 self.display_size=,16),display_size]
 # debug模式
 self.debug_mode=debug_mode
 # 人脸mesh参数均值
 self.param_mean = np.array(,dtype=np.float)
 # 人脸mesh参数方差
 self.param_std = np.array(,dtype=np.float)
 # 实例化Ai2d，用于实现模型预处理
 self.ai2d=Ai2d(debug_mode)
 # 设置Ai2d的输入输出格式和类型
 self.ai2d.set_ai2d_dtype(nn.ai2d_format.NCHW_FMT,nn.ai2d_format.NCHW_FMT,np.uint8, np.uint8)

# 配置预处理操作，这里使用了crop和resize，Ai2d支持crop/shift/pad/resize/affine，具体代码请打开/sdcard/app/libs/AI2D.py查看
def config_preprocess(self,det,input_image_size=None):
 with ScopedTiming("set preprocess config",self.debug_mode > 0):
 # 初始化ai2d预处理配置，默认为sensor给到AI的尺寸，可以通过设置input_image_size自行修改输入尺寸
 ai2d_input_size=input_image_size if input_image_size else self.rgb888p_size
 # 计算crop参数，并设置crop预处理
 roi = self.parse_roi_box_from_bbox(det)
 self.ai2d.crop(int(roi),int(roi),int(roi),int(roi))
 # 设置resize预处理
 self.ai2d.resize(nn.interp_method.tf_bilinear, nn.interp_mode.half_pixel)
 # 构建预处理流程,参数为预处理输入tensor的shape和预处理输出的tensor的shape
 self.ai2d.build(,ai2d_input_size],,self.model_input_size])
 return roi

# 自定义后处理，results是模型输出的array列表
def postprocess(self,results):
 with ScopedTiming("postprocess",self.debug_mode > 0):
 param = results * self.param_std + self.param_mean
 return param

def parse_roi_box_from_bbox(self,bbox):
 # 获取人脸roi
 x1, y1, w, h = map(lambda x: int(round(x, 0)), bbox[:4])
 old_size = (w + h) / 2
 center_x = x1 + w / 2
 center_y = y1 + h / 2 + old_size * 0.14
 size = int(old_size * 1.58)
 x0 = center_x - float(size) / 2
 y0 = center_y - float(size) / 2
 x1 = x0 + size
 y1 = y0 + size
 x0 = max(0, min(x0, self.rgb888p_size))
 y0 = max(0, min(y0, self.rgb888p_size))
 x1 = max(0, min(x1, self.rgb888p_size))
 y1 = max(0, min(y1, self.rgb888p_size))
 roi = (x0, y0, x1 - x0, y1 - y0)
 return roi

# 自定义人脸网格后处理任务类
class FaceMeshPostApp(AIBase):
def __init__(self,kmodel_path,model_input_size,rgb888p_size=,display_size=,debug_mode=0):
 super().__init__(kmodel_path,model_input_size,rgb888p_size,debug_mode)
 # kmodel路径
 self.kmodel_path=kmodel_path
 # 人脸网格模型输入分辨率
 self.model_input_size=model_input_size
 # sensor给到AI的图像分辨率，宽16字节对齐
 self.rgb888p_size=,16),rgb888p_size]
 # 视频输出VO分辨率，宽16字节对齐
 self.display_size=,16),display_size]
 # debug模式
 self.debug_mode=debug_mode
 # 实例化Ai2d，用于实现模型预处理
 self.ai2d=Ai2d(debug_mode)
 # 设置Ai2d的输入输出格式和类型
 self.ai2d.set_ai2d_dtype(nn.ai2d_format.NCHW_FMT,nn.ai2d_format.NCHW_FMT,np.uint8, np.uint8)

# 重写预处理函数preprocess，因为该模型的预处理不是单纯调用一个ai2d能实现的，返回模型输入的tensor列表
def preprocess(self,param):
 with ScopedTiming("set preprocess config",self.debug_mode > 0):
 # face mesh post模型预处理，param解析
 param = param
 trans_dim, shape_dim, exp_dim = 12, 40, 10
 R_ = param[:trans_dim].copy().reshape((3, -1))
 R = R_[:, :3].copy()
 offset = R_[:, 3].copy()
 offset = offset.reshape((3, 1))
 alpha_shp = param.copy().reshape((-1, 1))
 alpha_exp = param.copy().reshape((-1, 1))
 R_tensor = nn.from_numpy(R)
 offset_tensor = nn.from_numpy(offset)
 alpha_shp_tensor = nn.from_numpy(alpha_shp)
 alpha_exp_tensor = nn.from_numpy(alpha_exp)
 return

# 自定义模型后处理，这里调用了aidemo的face_mesh_post_process接口
def postprocess(self,results,roi):
 with ScopedTiming("postprocess",self.debug_mode > 0):
 x, y, w, h = map(lambda x: int(round(x, 0)), roi[:4])
 x = x * self.display_size // self.rgb888p_size
 y = y * self.display_size // self.rgb888p_size
 w = w * self.display_size // self.rgb888p_size
 h = h * self.display_size // self.rgb888p_size
 roi_array = np.array(,dtype=np.float)
 aidemo.face_mesh_post_process(roi_array,results)
 return results

# 3D人脸网格
class FaceMesh:
def __init__(self,face_det_kmodel,face_mesh_kmodel,mesh_post_kmodel,det_input_size,mesh_input_size,anchors,confidence_threshold=0.25,nms_threshold=0.3,rgb888p_size=,display_size=,debug_mode=0):
 # 人脸检测模型路径
 self.face_det_kmodel=face_det_kmodel
 # 人脸3D网格模型路径
 self.face_mesh_kmodel=face_mesh_kmodel
 # 人脸3D网格后处理模型路径
 self.mesh_post_kmodel=mesh_post_kmodel
 # 人脸检测模型输入分辨率
 self.det_input_size=det_input_size
 # 人脸3D网格模型输入分辨率
 self.mesh_input_size=mesh_input_size
 # anchors
 self.anchors=anchors
 # 置信度阈值
 self.confidence_threshold=confidence_threshold
 # nms阈值
 self.nms_threshold=nms_threshold
 # sensor给到AI的图像分辨率，宽16字节对齐
 self.rgb888p_size=,16),rgb888p_size]
 # 视频输出VO分辨率，宽16字节对齐
 self.display_size=,16),display_size]
 # debug_mode模式
 self.debug_mode=debug_mode
 # 人脸检测实例
 self.face_det=FaceDetApp(self.face_det_kmodel,model_input_size=self.det_input_size,anchors=self.anchors,confidence_threshold=self.confidence_threshold,nms_threshold=self.nms_threshold,rgb888p_size=self.rgb888p_size,display_size=self.display_size,debug_mode=0)
 # 人脸网格实例
 self.face_mesh=FaceMeshApp(self.face_mesh_kmodel,model_input_size=self.mesh_input_size,rgb888p_size=self.rgb888p_size,display_size=self.display_size)
 # 人脸网格后处理实例
 self.face_mesh_post=FaceMeshPostApp(self.mesh_post_kmodel,model_input_size=self.mesh_input_size,rgb888p_size=self.rgb888p_size,display_size=self.display_size)
 # 人脸检测预处理配置
 self.face_det.config_preprocess()

# run函数
def run(self,input_np):
 # 执行人脸检测
 det_boxes=self.face_det.run(input_np)
 mesh_res=[]
 for det_box in det_boxes:
 # 对检测到的每一个人脸配置预处理，执行人脸网格和人脸网格后处理
 roi=self.face_mesh.config_preprocess(det_box)
 param=self.face_mesh.run(input_np)
 tensors=self.face_mesh_post.preprocess(param)
 results=self.face_mesh_post.inference(tensors)
 res=self.face_mesh_post.postprocess(results,roi)
 mesh_res.append(res)
 return det_boxes,mesh_res

# 绘制人脸解析效果
def draw_result(self,pl,dets,mesh_res):
 pl.osd_img.clear()
 if dets:
 draw_img_np = np.zeros((self.display_size,self.display_size,4),dtype=np.uint8)
 draw_img = image.Image(self.display_size, self.display_size, image.ARGB8888, alloc=image.ALLOC_REF,data = draw_img_np)
 for vertices in mesh_res:
 aidemo.face_draw_mesh(draw_img_np, vertices)
 pl.osd_img.copy_from(draw_img)

if __name__=="__main__":
# 显示模式，默认"hdmi",可以选择"hdmi"和"lcd"
display_mode="lcd"
if display_mode=="hdmi":
 display_size=
else:
 display_size=
# 人脸检测模型路径
face_det_kmodel_path="/sdcard/app/tests/kmodel/face_detection_320.kmodel"
# 人脸网格模型路径
face_mesh_kmodel_path="/sdcard/app/tests/kmodel/face_alignment.kmodel"
# 人脸网格后处理模型路径
face_mesh_post_kmodel_path="/sdcard/app/tests/kmodel/face_alignment_post.kmodel"
# 其他参数
anchors_path="/sdcard/app/tests/utils/prior_data_320.bin"
rgb888p_size=
face_det_input_size=
face_mesh_input_size=
confidence_threshold=0.5
nms_threshold=0.2
anchor_len=4200
det_dim=4
anchors = np.fromfile(anchors_path, dtype=np.float)
anchors = anchors.reshape((anchor_len,det_dim))

# 初始化PipeLine，只关注传给AI的图像分辨率，显示的分辨率
pl=PipeLine(rgb888p_size=rgb888p_size,display_size=display_size,display_mode=display_mode)
pl.create()
fm=FaceMesh(face_det_kmodel_path,face_mesh_kmodel_path,face_mesh_post_kmodel_path,det_input_size=face_det_input_size,mesh_input_size=face_mesh_input_size,anchors=anchors,confidence_threshold=confidence_threshold,nms_threshold=nms_threshold,rgb888p_size=rgb888p_size,display_size=display_size)

clock = time.clock()

try:
 while True:

 os.exitpoint()

 clock.tick()

 img=pl.get_frame() # 获取当前帧
 det_boxes,mesh_res=fm.run(img) # 推理当前帧
 print(det_boxes,mesh_res) # 打印结果
 fm.draw_result(pl,det_boxes,mesh_res) # 绘制推理结果
 pl.show_image() # 显示推理效果
 gc.collect()

 print(clock.fps()) #打印帧率

except Exception as e:
 sys.print_exception(e)
finally:
 fm.face_det.deinit()
 fm.face_mesh.deinit()
 fm.face_mesh_post.deinit()
 pl.destroy()</code></pre>

    可以看到使用默认配置后只使用了4行代码便实现了获取当前帧图像、AI推理、绘制结果、显示结果的识别流程。代码中det_boxes变量为人脸检测结果， mesh_res为网格点数据。

<pre>
<code class="language-python"> ...
 while True:

 os.exitpoint()

 clock.tick()

 img=pl.get_frame() # 获取当前帧
 det_boxes,mesh_res=fm.run(img) # 推理当前帧
 print(det_boxes,mesh_res) # 打印结果
 fm.draw_result(pl,det_boxes,mesh_res) # 绘制推理结果
 pl.show_image() # 显示推理效果
 gc.collect()

 print(clock.fps()) #打印帧率
 ...</code></pre>

    实验结果如下：

 

2、人体相关

    人体关键点检测是指标注出人体关节等关键信息，分析人体姿态、运动轨迹、动作角度等。检测摄像头拍摄到的画面中的人体关键点并通过画图提示。

    本实验通过CanMV K230 AI视觉框架开发，用到的模型已经存放在CanMV K230的文件系统，无需额外拷贝。

    具体编程思路如下：

  

    自定义人体关键点检测类。

    人体关键点检测类（PersonKeyPointApp）：

    初始化（__init__）：

       设置模型路径、模型输入尺寸、置信度阈值、非极大值抑制（NMS）阈值、RGB图像尺寸、显示尺寸和调试模式。

       初始化骨骼信息和关键点颜色，用于后续绘制关键点和骨骼。

    预处理配置（config_preprocess）：

       配置Ai2d实例，用于实现模型预处理，包括填充（pad）和缩放（resize）操作。

    后处理（postprocess）：

       对模型的推理结果进行后处理，使用aidemo库的person_kp_postprocess接口，根据置信度阈值和NMS阈值过滤和处理关键点。

    绘制结果（draw_result）：

      将处理后的关键点和骨骼信息绘制到图像上，使用不同的颜色区分不同的骨骼和关键点。

    计算填充参数（get_padding_param）：

       计算为了将输入图像调整到模型输入尺寸所需的填充参数。

    主函数的思路：

    设置显示模式和尺寸：

        根据选择的显示模式（HDMI或LCD），设置显示尺寸。

    初始化模型和参数：

       设置模型路径、置信度阈值、NMS阈值和RGB图像尺寸。

    创建PipeLine：

       初始化PipeLine实例，用于管理图像的获取和显示。

    初始化人体关键点检测实例：

       创建PersonKeyPointApp类的实例，并配置预处理操作。

    主循环：

       在一个无限循环中，不断获取当前帧图像，进行推理，绘制结果，并显示。

       使用clock对象来计算和打印帧率。

    异常处理：

       捕获异常，打印异常信息，并在退出前释放相关资源。

    参考代码如下：

<pre>
<code class="language-python">'''
实验名称：人体关键点检测
实验平台：01Studio CanMV K230
教程：wiki.01studio.cc
'''

from libs.PipeLine import PipeLine, ScopedTiming
from libs.AIBase import AIBase
from libs.AI2D import Ai2d
import os
import ujson
from media.media import *
from time import *
import nncase_runtime as nn
import ulab.numpy as np
import time
import utime
import image
import random
import gc
import sys
import aidemo

# 自定义人体关键点检测类
class PersonKeyPointApp(AIBase):
def __init__(self,kmodel_path,model_input_size,confidence_threshold=0.2,nms_threshold=0.5,rgb888p_size=,display_size=,debug_mode=0):
 super().__init__(kmodel_path,model_input_size,rgb888p_size,debug_mode)
 self.kmodel_path=kmodel_path
 # 模型输入分辨率
 self.model_input_size=model_input_size
 # 置信度阈值设置
 self.confidence_threshold=confidence_threshold
 # nms阈值设置
 self.nms_threshold=nms_threshold
 # sensor给到AI的图像分辨率
 self.rgb888p_size=,16),rgb888p_size]
 # 显示分辨率
 self.display_size=,16),display_size]
 self.debug_mode=debug_mode
 #骨骼信息
 self.SKELETON = [(16, 14),(14, 12),(17, 15),(15, 13),(12, 13),(6,12),(7,13),(6,7),(6,8),(7,9),(8,10),(9,11),(2,3),(1,2),(1,3),(2,4),(3,5),(4,6),(5,7)]
 #肢体颜色
 self.LIMB_COLORS = [(255, 51,153, 255),(255, 51,153, 255),(255, 51,153, 255),(255, 51,153, 255),(255, 255, 51,255),(255, 255, 51,255),(255, 255, 51,255),(255, 255, 128, 0),(255, 255, 128, 0),(255, 255, 128, 0),(255, 255, 128, 0),(255, 255, 128, 0),(255, 0, 255, 0),(255, 0, 255, 0),(255, 0, 255, 0),(255, 0, 255, 0),(255, 0, 255, 0),(255, 0, 255, 0),(255, 0, 255, 0)]
 #关键点颜色，共17个
 self.KPS_COLORS = [(255, 0, 255, 0),(255, 0, 255, 0),(255, 0, 255, 0),(255, 0, 255, 0),(255, 0, 255, 0),(255, 255, 128, 0),(255, 255, 128, 0),(255, 255, 128, 0),(255, 255, 128, 0),(255, 255, 128, 0),(255, 255, 128, 0),(255, 51,153, 255),(255, 51,153, 255),(255, 51,153, 255),(255, 51,153, 255),(255, 51,153, 255),(255, 51,153, 255)]

 # Ai2d实例，用于实现模型预处理
 self.ai2d=Ai2d(debug_mode)
 # 设置Ai2d的输入输出格式和类型
 self.ai2d.set_ai2d_dtype(nn.ai2d_format.NCHW_FMT,nn.ai2d_format.NCHW_FMT,np.uint8, np.uint8)

# 配置预处理操作，这里使用了pad和resize，Ai2d支持crop/shift/pad/resize/affine，具体代码请打开/sdcard/app/libs/AI2D.py查看
def config_preprocess(self,input_image_size=None):
 with ScopedTiming("set preprocess config",self.debug_mode > 0):
 # 初始化ai2d预处理配置，默认为sensor给到AI的尺寸，您可以通过设置input_image_size自行修改输入尺寸
 ai2d_input_size=input_image_size if input_image_size else self.rgb888p_size
 top,bottom,left,right=self.get_padding_param()
 self.ai2d.pad(, 0, )
 self.ai2d.resize(nn.interp_method.tf_bilinear, nn.interp_mode.half_pixel)
 self.ai2d.build(,ai2d_input_size],,self.model_input_size])

# 自定义当前任务的后处理
def postprocess(self,results):
 with ScopedTiming("postprocess",self.debug_mode > 0):
 # 这里使用了aidemo库的person_kp_postprocess接口
 results = aidemo.person_kp_postprocess(results,,self.rgb888p_size],self.model_input_size,self.confidence_threshold,self.nms_threshold)
 return results

#绘制结果，绘制人体关键点
def draw_result(self,pl,res):
 with ScopedTiming("display_draw",self.debug_mode >0):
 if res:
 pl.osd_img.clear()
 kpses = res
 for i in range(len(res)):
 for k in range(17+2):
 if (k < 17):
 kps_x,kps_y,kps_s = round(kpses),round(kpses),kpses
 kps_x1 = int(float(kps_x) * self.display_size // self.rgb888p_size)
 kps_y1 = int(float(kps_y) * self.display_size // self.rgb888p_size)
 if (kps_s > 0):
 pl.osd_img.draw_circle(kps_x1,kps_y1,5,self.KPS_COLORS,4)
 ske = self.SKELETON
 pos1_x,pos1_y= round(kpses-1]),round(kpses-1])
 pos1_x_ = int(float(pos1_x) * self.display_size // self.rgb888p_size)
 pos1_y_ = int(float(pos1_y) * self.display_size // self.rgb888p_size)

 pos2_x,pos2_y = round(kpses[(ske -1)]),round(kpses[(ske -1)])
 pos2_x_ = int(float(pos2_x) * self.display_size // self.rgb888p_size)
 pos2_y_ = int(float(pos2_y) * self.display_size // self.rgb888p_size)

 pos1_s,pos2_s = kpses[(ske -1)],kpses[(ske -1)]
 if (pos1_s > 0.0 and pos2_s >0.0):
 pl.osd_img.draw_line(pos1_x_,pos1_y_,pos2_x_,pos2_y_,self.LIMB_COLORS,4)
 gc.collect()
 else:
 pl.osd_img.clear()

# 计算padding参数
def get_padding_param(self):
 dst_w = self.model_input_size
 dst_h = self.model_input_size
 input_width = self.rgb888p_size
 input_high = self.rgb888p_size
 ratio_w = dst_w / input_width
 ratio_h = dst_h / input_high
 if ratio_w < ratio_h:
 ratio = ratio_w
 else:
 ratio = ratio_h
 new_w = (int)(ratio * input_width)
 new_h = (int)(ratio * input_high)
 dw = (dst_w - new_w) / 2
 dh = (dst_h - new_h) / 2
 top = int(round(dh - 0.1))
 bottom = int(round(dh + 0.1))
 left = int(round(dw - 0.1))
 right = int(round(dw - 0.1))
 returntop, bottom, left, right

if __name__=="__main__":
# 显示模式，默认"hdmi",可以选择"hdmi"和"lcd"
display_mode="lcd"
if display_mode=="hdmi":
 display_size=
else:
 display_size=
# 模型路径
kmodel_path="/sdcard/app/tests/kmodel/yolov8n-pose.kmodel"
# 其它参数设置
confidence_threshold = 0.2
nms_threshold = 0.5
rgb888p_size=
# 初始化PipeLine
pl=PipeLine(rgb888p_size=rgb888p_size,display_size=display_size,display_mode=display_mode)
pl.create()
# 初始化自定义人体关键点检测实例
person_kp=PersonKeyPointApp(kmodel_path,model_input_size=,confidence_threshold=confidence_threshold,nms_threshold=nms_threshold,rgb888p_size=rgb888p_size,display_size=display_size,debug_mode=0)
person_kp.config_preprocess()

clock = time.clock()

try:
 while True:

 os.exitpoint()

 clock.tick()

 img=pl.get_frame()# 获取当前帧数据
 res=person_kp.run(img)# 推理当前帧
 person_kp.draw_result(pl,res)# 绘制结果到PipeLine的osd图像
 print(res)#打印结果
 pl.show_image()# 显示当前的绘制结果
 gc.collect()

 print(clock.fps()) #打印帧率

#IDE中断释放相关资源
except Exception as e:
 sys.print_exception(e)
finally:
 person_kp.deinit()
 pl.destroy()</code></pre>

    实验结果：



   

3、车牌相关

    车牌识别对找出的车牌进行车牌内容识别。识别摄像头拍摄到的画面中的车牌内容并通过写字符和画图指示。

    通过CanMV K230 AI视觉框架开发，用到的模型已经存放在CanMV K230的文件系统，无需额外拷贝。

    具体的编程思路如下：

  

    自定义车牌检测类，车牌识别任务类（继承于AIBase类），车牌识别任务类。

    LicenceDetectionApp类（车牌检测类）：

       这个类负责车牌的检测工作。

       初始化函数中设置了车牌检测应用的参数，如模型路径、模型输入尺寸、置信度阈值、NMS阈值、RGB图像尺寸和显示尺寸。

       config_preprocess方法配置了预处理操作，这里使用了resize操作来调整输入图像的尺寸以匹配模型的输入要求。

       postprocess方法对检测结果进行后处理，使用aidemo.licence_det_postprocess接口，根据置信度阈值和NMS阈值过滤和处理检测结果。

    LicenceRecognitionApp 类（车牌识别类）：

       这个类负责对检测到的车牌进行识别。

       初始化函数中设置了车牌识别应用的参数，包括模型路径、模型输入尺寸、RGB图像尺寸和显示尺寸。

       config_preprocess 方法配置了预处理操作，同样使用了resize操作。

       postprocess 方法对识别结果进行后处理，将模型输出的数组转换为车牌上的字符序列。

    LicenceRec 类（车牌识别任务类）：

       这个类整合了车牌检测和识别的功能。

       初始化函数中接收车牌检测和识别模型的路径、输入尺寸等参数，并初始化了LicenceDetectionApp和LicenceRecognitionApp两个实例。

       run 方法执行车牌检测，并将检测到的车牌区域抠出来，然后对每个车牌区域进行识别。

      draw_result 方法将检测和识别的结果绘制到图像上，显示车牌的边界框和识别出的车牌号码。

    主函数的思路：

    设置显示模式和尺寸：

       根据选择的显示模式（HDMI或LCD），设置显示尺寸。

    初始化模型和参数：

       设置车牌检测和识别模型的路径、输入尺寸、置信度阈值和NMS阈值。

    创建PipeLine实例：

       初始化PipeLine，管理图像的获取和显示。

    初始化车牌识别任务实例：

       创建LicenceRec类的实例，整合车牌检测和识别的功能，并配置预处理操作。

    主循环：

   在一个无限循环中，不断获取当前帧图像，进行车牌检测和识别，绘制结果，并显示。

   使用clock对象来计算和打印帧率。

    异常处理：

       捕获异常，打印异常信息，并在退出前释放相关资源。

    参考代码如下：

    # 车牌字符字典

    self.dict_rec = ["挂", "使", "领", "澳", "港", "皖", "沪", "津", "渝", "冀", "晋", "蒙", "辽", "吉", "黑", "苏", "浙", "京", "闽", "赣", "鲁", "豫", "鄂", "湘", "粤", "桂", "琼", "川", "贵", "云", "藏", "陕", "甘", "青", "宁", "新", "警", "学", "0", 1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H", "J", "K", "L", "M", "N", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "_", "-"]列出了所有的车牌可能出现的结果。

<pre>
<code class="language-python">'''
实验名称：车牌识别
实验平台：01Studio CanMV K230
教程：wiki.01studio.cc
'''

from libs.PipeLine import PipeLine, ScopedTiming
from libs.AIBase import AIBase
from libs.AI2D import Ai2d
import os
import ujson
from media.media import *
from time import *
import nncase_runtime as nn
import ulab.numpy as np
import time
import image
import aidemo
import random
import gc
import sys

# 自定义车牌检测类
class LicenceDetectionApp(AIBase):
# 初始化函数，设置车牌检测应用的参数
def __init__(self, kmodel_path, model_input_size, confidence_threshold=0.5, nms_threshold=0.2, rgb888p_size=, display_size=, debug_mode=0):
 super().__init__(kmodel_path, model_input_size, rgb888p_size, debug_mode)# 调用基类的初始化函数
 self.kmodel_path = kmodel_path# 模型路径
 # 模型输入分辨率
 self.model_input_size = model_input_size
 # 分类阈值
 self.confidence_threshold = confidence_threshold
 self.nms_threshold = nms_threshold
 # sensor给到AI的图像分辨率
 self.rgb888p_size = , 16), rgb888p_size]
 # 显示分辨率
 self.display_size = , 16), display_size]
 self.debug_mode = debug_mode
 # Ai2d实例，用于实现模型预处理
 self.ai2d = Ai2d(debug_mode)
 # 设置Ai2d的输入输出格式和类型
 self.ai2d.set_ai2d_dtype(nn.ai2d_format.NCHW_FMT, nn.ai2d_format.NCHW_FMT, np.uint8, np.uint8)

# 配置预处理操作，这里使用了pad和resize，Ai2d支持crop/shift/pad/resize/affine
def config_preprocess(self, input_image_size=None):
 with ScopedTiming("set preprocess config", self.debug_mode > 0):
 # 初始化ai2d预处理配置，默认为sensor给到AI的尺寸，可以通过设置input_image_size自行修改输入尺寸
 ai2d_input_size = input_image_size if input_image_size else self.rgb888p_size
 self.ai2d.resize(nn.interp_method.tf_bilinear, nn.interp_mode.half_pixel)
 self.ai2d.build(,ai2d_input_size],,self.model_input_size])

# 自定义当前任务的后处理
def postprocess(self, results):
 with ScopedTiming("postprocess", self.debug_mode > 0):
 # 对检测结果进行后处理
 det_res = aidemo.licence_det_postprocess(results, , self.rgb888p_size], self.model_input_size, self.confidence_threshold, self.nms_threshold)
 return det_res

# 自定义车牌识别任务类
class LicenceRecognitionApp(AIBase):
def __init__(self,kmodel_path,model_input_size,rgb888p_size=,display_size=,debug_mode=0):
 super().__init__(kmodel_path,model_input_size,rgb888p_size,debug_mode)
 # kmodel路径
 self.kmodel_path=kmodel_path
 # 检测模型输入分辨率
 self.model_input_size=model_input_size
 # sensor给到AI的图像分辨率，宽16字节对齐
 self.rgb888p_size=,16),rgb888p_size]
 # 视频输出VO分辨率，宽16字节对齐
 self.display_size=,16),display_size]
 # debug模式
 self.debug_mode=debug_mode
 # 车牌字符字典
 self.dict_rec = ["挂", "使", "领", "澳", "港", "皖", "沪", "津", "渝", "冀", "晋", "蒙", "辽", "吉", "黑", "苏", "浙", "京", "闽", "赣", "鲁", "豫", "鄂", "湘", "粤", "桂", "琼", "川", "贵", "云", "藏", "陕", "甘", "青", "宁", "新", "警", "学", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H", "J", "K", "L", "M", "N", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "_", "-"]
 self.dict_size = len(self.dict_rec)
 self.ai2d=Ai2d(debug_mode)
 self.ai2d.set_ai2d_dtype(nn.ai2d_format.NCHW_FMT,nn.ai2d_format.NCHW_FMT,np.uint8, np.uint8)

# 配置预处理操作，这里使用了resize，Ai2d支持crop/shift/pad/resize/affine
def config_preprocess(self,input_image_size=None):
 with ScopedTiming("set preprocess config",self.debug_mode > 0):
 ai2d_input_size=input_image_size if input_image_size else self.rgb888p_size
 self.ai2d.resize(nn.interp_method.tf_bilinear, nn.interp_mode.half_pixel)
 self.ai2d.build(,ai2d_input_size],,self.model_input_size])

# 自定义后处理，results是模型输出的array列表
def postprocess(self,results):
 with ScopedTiming("postprocess",self.debug_mode > 0):
 output_data=results.reshape((-1,self.dict_size))
 max_indices = np.argmax(output_data, axis=1)
 result_str = ""
 for i in range(max_indices.shape):
 index = max_indices
 if index > 0 and (i == 0 or index != max_indices):
 result_str += self.dict_rec
 return result_str

# 车牌识别任务类
class LicenceRec:
def __init__(self,licence_det_kmodel,licence_rec_kmodel,det_input_size,rec_input_size,confidence_threshold=0.25,nms_threshold=0.3,rgb888p_size=,display_size=,debug_mode=0):
 # 车牌检测模型路径
 self.licence_det_kmodel=licence_det_kmodel
 # 车牌识别模型路径
 self.licence_rec_kmodel=licence_rec_kmodel
 # 人脸检测模型输入分辨率
 self.det_input_size=det_input_size
 # 人脸姿态模型输入分辨率
 self.rec_input_size=rec_input_size
 # 置信度阈值
 self.confidence_threshold=confidence_threshold
 # nms阈值
 self.nms_threshold=nms_threshold
 # sensor给到AI的图像分辨率，宽16字节对齐
 self.rgb888p_size=,16),rgb888p_size]
 # 视频输出VO分辨率，宽16字节对齐
 self.display_size=,16),display_size]
 # debug_mode模式
 self.debug_mode=debug_mode
 self.licence_det=LicenceDetectionApp(self.licence_det_kmodel,model_input_size=self.det_input_size,confidence_threshold=self.confidence_threshold,nms_threshold=self.nms_threshold,rgb888p_size=self.rgb888p_size,display_size=self.display_size,debug_mode=0)
 self.licence_rec=LicenceRecognitionApp(self.licence_rec_kmodel,model_input_size=self.rec_input_size,rgb888p_size=self.rgb888p_size)
 self.licence_det.config_preprocess()

# run函数
def run(self,input_np):
 # 执行车牌检测
 det_boxes=self.licence_det.run(input_np)
 # 将车牌部分抠出来
 imgs_array_boxes = aidemo.ocr_rec_preprocess(input_np,,self.rgb888p_size],det_boxes)
 imgs_array = imgs_array_boxes
 boxes = imgs_array_boxes
 rec_res = []
 for img_array in imgs_array:
 # 对每一个检测到的车牌进行识别
 self.licence_rec.config_preprocess(input_image_size=,img_array.shape])
 licence_str=self.licence_rec.run(img_array)
 rec_res.append(licence_str)
 gc.collect()
 return det_boxes,rec_res

# 绘制车牌检测识别效果
def draw_result(self,pl,det_res,rec_res):
 pl.osd_img.clear()
 if det_res:
 point_8 = np.zeros((8),dtype=np.int16)
 for det_index in range(len(det_res)):
 for i in range(4):
 x = det_res/self.rgb888p_size*self.display_size
 y = det_res/self.rgb888p_size*self.display_size
 point_8 = int(x)
 point_8 = int(y)
 for i in range(4):
 pl.osd_img.draw_line(point_8,point_8,point_8[(i+1) % 4 * 2 + 0],point_8[(i+1) % 4 * 2 + 1],color=(255, 0, 255, 0),thickness=4)
 pl.osd_img.draw_string_advanced( point_8, point_8 + 20, 40,rec_res , color=(255,255,153,18))

if __name__=="__main__":
# 显示模式，默认"hdmi",可以选择"hdmi"和"lcd"
display_mode="lcd"
if display_mode=="hdmi":
 display_size=
else:
 display_size=
# 车牌检测模型路径
licence_det_kmodel_path="/sdcard/app/tests/kmodel/LPD_640.kmodel"
# 车牌识别模型路径
licence_rec_kmodel_path="/sdcard/app/tests/kmodel/licence_reco.kmodel"
# 其它参数
rgb888p_size=
licence_det_input_size=
licence_rec_input_size=
confidence_threshold=0.2
nms_threshold=0.2

# 初始化PipeLine，只关注传给AI的图像分辨率，显示的分辨率
pl=PipeLine(rgb888p_size=rgb888p_size,display_size=display_size,display_mode=display_mode)
pl.create()
lr=LicenceRec(licence_det_kmodel_path,licence_rec_kmodel_path,det_input_size=licence_det_input_size,rec_input_size=licence_rec_input_size,confidence_threshold=confidence_threshold,nms_threshold=nms_threshold,rgb888p_size=rgb888p_size,display_size=display_size)

clock = time.clock()

try:
 while True:

 os.exitpoint()

 clock.tick()
 img=pl.get_frame() # 获取当前帧
 det_res,rec_res=lr.run(img) # 推理当前帧
 lr.draw_result(pl,det_res,rec_res)# 绘制当前帧推理结果
 print(det_res,rec_res) #打印结果
 pl.show_image() # 展示推理结果
 gc.collect()

 print(clock.fps()) #打印帧率

except Exception as e:
 sys.print_exception(e)
finally:
 lr.licence_det.deinit()
 lr.licence_rec.deinit()
 pl.destroy()</code></pre>

    实验结果如下：



   

    某次结果, dtype=float32)] ['\u82cfE991N6']，['\u82cfE991N6']为识别结果，”u”为汉字的Unicode编码，82cf为汉字“苏”的编码编码结果，所以车牌为“苏E991N6”。

4、字符识别

    OCR （Optical Character Recognition，光学字符识别）是指电子设备（例如扫描仪或数码相机）检查纸上打印的字符，通过检测暗、亮的模式确定其形状，然后用字符识别方法将形状翻译成计算机文字的过程。关键是从图像中提取有助于区分不同字符的特征，这些特征可能包括形状、边缘、纹理、笔画结构等。然后将提取的特征与已知的字符模板或模型进行匹配，以识别图像中的字符。

    编程实现图片中的字符识别（支持中文和英文），通过CanMV K230 AI视觉框架开发，用到的模型已经存放在CanMV K230的文件系统，无需额外拷贝。

    具体编程思路如下：

  

    自定义OCR检测类，OCR识别类，OCR检测识别类。

    OCRDetectionApp 类（OCR检测类）：

       这个类负责检测图像中的文本区域。

       初始化函数中设置了检测模型的路径、模型输入尺寸、掩码阈值、文本框阈值、RGB图像尺寸和显示尺寸。

       config_preprocess 方法配置了预处理操作，包括填充（pad）和缩放（resize）。

       postprocess 方法对检测结果进行后处理，使用 aicube.ocr_post_process 接口，返回检测到的文本区域的坐标。

       get_padding_param 方法计算填充参数，以确保输入图像的尺寸与模型输入尺寸匹配。

       chw2hwc 方法将通道在前的图像数据（CHW）转换为通道在后的图像数据（HWC）。

    OCRRecognitionApp 类（OCR识别类）：

       这个类负责识别检测到的文本区域中的字符。

       初始化函数中设置了识别模型的路径、模型输入尺寸、字典路径、RGB图像尺寸和显示尺寸。

       config_preprocess 方法配置了预处理操作，包括填充（pad）和缩放（resize）。

       postprocess 方法对识别结果进行后处理，将模型输出的数组转换为文本字符串。

       get_padding_param 方法计算填充参数，以确保输入图像的尺寸与模型输入尺寸匹配。

       read_dict 方法读取OCR字典，该字典用于将识别结果的数字索引转换为对应的字符。

    OCRDetRec 类（OCR检测识别类）：

       这个类整合了OCR检测和识别的功能。

       初始化函数中接收OCR检测和识别模型的路径、输入尺寸、字典路径等参数，并初始化了 OCRDetectionApp 和 OCRRecognitionApp 两个实例。

       run 方法执行OCR检测，并将检测到的文本区域传递给识别类进行识别。

       draw_result 方法将检测和识别的结果绘制到图像上，显示文本区域的边界框和识别出的文本内容。

    主函数的思路：

    设置显示模式和尺寸：

       根据选择的显示模式（HDMI或LCD），设置显示尺寸。

    初始化模型和参数：

       设置OCR检测和识别模型的路径、字典路径、输入尺寸、掩码阈值、文本框阈值。

    创建 PipeLine 实例：

       初始化 PipeLine，管理图像的获取和显示。

    初始化OCR检测识别实例：

       创建 OCRDetRec 类的实例，整合OCR检测和识别的功能，并配置预处理操作。

    主循环：

       在一个无限循环中，不断获取当前帧图像，进行OCR检测和识别，绘制结果，并显示。

       使用 clock 对象来计算和打印帧率。

        异常处理：

           捕获异常，打印异常信息，并在退出前释放相关资源。

    参考代码如下：

<pre>
<code class="language-python">'''
实验名称：字符识别（OCR）
实验平台：01Studio CanMV K230
教程：wiki.01studio.cc
'''

from libs.PipeLine import PipeLine, ScopedTiming
from libs.AIBase import AIBase
from libs.AI2D import Ai2d
import os
import ujson
from media.media import *
from time import *
import nncase_runtime as nn
import ulab.numpy as np
import time
import image
import aicube
import random
import gc
import sys

# 自定义OCR检测类
class OCRDetectionApp(AIBase):
def __init__(self,kmodel_path,model_input_size,mask_threshold=0.5,box_threshold=0.2,rgb888p_size=,display_size=,debug_mode=0):
 super().__init__(kmodel_path,model_input_size,rgb888p_size,debug_mode)
 self.kmodel_path=kmodel_path
 # 模型输入分辨率
 self.model_input_size=model_input_size
 # 分类阈值
 self.mask_threshold=mask_threshold
 self.box_threshold=box_threshold
 # sensor给到AI的图像分辨率
 self.rgb888p_size=,16),rgb888p_size]
 # 显示分辨率
 self.display_size=,16),display_size]
 self.debug_mode=debug_mode
 # Ai2d实例，用于实现模型预处理
 self.ai2d=Ai2d(debug_mode)
 # 设置Ai2d的输入输出格式和类型
 self.ai2d.set_ai2d_dtype(nn.ai2d_format.NCHW_FMT,nn.ai2d_format.NCHW_FMT,np.uint8, np.uint8)

# 配置预处理操作，这里使用了pad和resize，Ai2d支持crop/shift/pad/resize/affine，具体代码请打开/sdcard/app/libs/AI2D.py查看
def config_preprocess(self,input_image_size=None):
 with ScopedTiming("set preprocess config",self.debug_mode > 0):
 # 初始化ai2d预处理配置，默认为sensor给到AI的尺寸，您可以通过设置input_image_size自行修改输入尺寸
 ai2d_input_size=input_image_size if input_image_size else self.rgb888p_size
 top,bottom,left,right=self.get_padding_param()
 self.ai2d.pad(, 0, )
 self.ai2d.resize(nn.interp_method.tf_bilinear, nn.interp_mode.half_pixel)
 self.ai2d.build(,ai2d_input_size],,self.model_input_size])

# 自定义当前任务的后处理
def postprocess(self,results):
 with ScopedTiming("postprocess",self.debug_mode > 0):
 # chw2hwc
 hwc_array=self.chw2hwc(self.cur_img)
 # 这里使用了aicube封装的接口ocr_post_process做后处理,返回的det_boxes结构为[],...]
 det_boxes = aicube.ocr_post_process(results[:,:,:,0].reshape(-1), hwc_array.reshape(-1),self.model_input_size,self.rgb888p_size, self.mask_threshold, self.box_threshold)
 return det_boxes

# 计算padding参数
def get_padding_param(self):
 # 右padding或下padding
 dst_w = self.model_input_size
 dst_h = self.model_input_size
 input_width = self.rgb888p_size
 input_high = self.rgb888p_size
 ratio_w = dst_w / input_width
 ratio_h = dst_h / input_high
 if ratio_w < ratio_h:
 ratio = ratio_w
 else:
 ratio = ratio_h
 new_w = (int)(ratio * input_width)
 new_h = (int)(ratio * input_high)
 dw = (dst_w - new_w) / 2
 dh = (dst_h - new_h) / 2
 top = (int)(round(0))
 bottom = (int)(round(dh * 2 + 0.1))
 left = (int)(round(0))
 right = (int)(round(dw * 2 - 0.1))
 returntop, bottom, left, right

# chw2hwc
def chw2hwc(self,features):
 ori_shape = (features.shape, features.shape, features.shape)
 c_hw_ = features.reshape((ori_shape, ori_shape * ori_shape))
 hw_c_ = c_hw_.transpose()
 new_array = hw_c_.copy()
 hwc_array = new_array.reshape((ori_shape, ori_shape, ori_shape))
 del c_hw_
 del hw_c_
 del new_array
 return hwc_array

# 自定义OCR识别任务类
class OCRRecognitionApp(AIBase):
def __init__(self,kmodel_path,model_input_size,dict_path,rgb888p_size=,display_size=,debug_mode=0):
 super().__init__(kmodel_path,model_input_size,rgb888p_size,debug_mode)
 # kmodel路径
 self.kmodel_path=kmodel_path
 # 识别模型输入分辨率
 self.model_input_size=model_input_size
 self.dict_path=dict_path
 # sensor给到AI的图像分辨率，宽16字节对齐
 self.rgb888p_size=,16),rgb888p_size]
 # 视频输出VO分辨率，宽16字节对齐
 self.display_size=,16),display_size]
 # debug模式
 self.debug_mode=debug_mode
 self.dict_word=None
 # 读取OCR的字典
 self.read_dict()
 self.ai2d=Ai2d(debug_mode)
 self.ai2d.set_ai2d_dtype(nn.ai2d_format.RGB_packed,nn.ai2d_format.NCHW_FMT,np.uint8, np.uint8)

# 配置预处理操作，这里使用了pad和resize，Ai2d支持crop/shift/pad/resize/affine，具体代码请打开/sdcard/app/libs/AI2D.py查看
def config_preprocess(self,input_image_size=None,input_np=None):
 with ScopedTiming("set preprocess config",self.debug_mode > 0):
 ai2d_input_size=input_image_size if input_image_size else self.rgb888p_size
 top,bottom,left,right=self.get_padding_param(ai2d_input_size,self.model_input_size)
 self.ai2d.pad(, 0, )
 self.ai2d.resize(nn.interp_method.tf_bilinear, nn.interp_mode.half_pixel)
 # 如果传入input_np，输入shape为input_np的shape,如果不传入，输入shape为,ai2d_input_size]
 self.ai2d.build(,input_np.shape,input_np.shape,input_np.shape],,self.model_input_size])

# 自定义后处理，results是模型输出的array列表
def postprocess(self,results):
 with ScopedTiming("postprocess",self.debug_mode > 0):
 preds = np.argmax(results, axis=2).reshape((-1))
 output_txt = ""
 for i in range(len(preds)):
 # 当前识别字符不是字典的最后一个字符并且和前一个字符不重复（去重），加入识别结果字符串
 if preds != (len(self.dict_word) - 1) and (not (i > 0 and preds == preds)):
 output_txt = output_txt + self.dict_word]
 return output_txt

# 计算padding参数
def get_padding_param(self,src_size,dst_size):
 # 右padding或下padding
 dst_w = dst_size
 dst_h = dst_size
 input_width = src_size
 input_high = src_size
 ratio_w = dst_w / input_width
 ratio_h = dst_h / input_high
 if ratio_w < ratio_h:
 ratio = ratio_w
 else:
 ratio = ratio_h
 new_w = (int)(ratio * input_width)
 new_h = (int)(ratio * input_high)
 dw = (dst_w - new_w) / 2
 dh = (dst_h - new_h) / 2
 top = (int)(round(0))
 bottom = (int)(round(dh * 2 + 0.1))
 left = (int)(round(0))
 right = (int)(round(dw * 2 - 0.1))
 returntop, bottom, left, right

def read_dict(self):
 if self.dict_path!="":
 with open(dict_path, 'r') as file:
 line_one = file.read(100000)
 line_list = line_one.split("\r\n")
 self.dict_word = {num: char.replace("\r", "").replace("\n", "") for num, char in enumerate(line_list)}

class OCRDetRec:
def __init__(self,ocr_det_kmodel,ocr_rec_kmodel,det_input_size,rec_input_size,dict_path,mask_threshold=0.25,box_threshold=0.3,rgb888p_size=,display_size=,debug_mode=0):
 # OCR检测模型路径
 self.ocr_det_kmodel=ocr_det_kmodel
 # OCR识别模型路径
 self.ocr_rec_kmodel=ocr_rec_kmodel
 # OCR检测模型输入分辨率
 self.det_input_size=det_input_size
 # OCR识别模型输入分辨率
 self.rec_input_size=rec_input_size
 # 字典路径
 self.dict_path=dict_path
 # 置信度阈值
 self.mask_threshold=mask_threshold
 # nms阈值
 self.box_threshold=box_threshold
 # sensor给到AI的图像分辨率，宽16字节对齐
 self.rgb888p_size=,16),rgb888p_size]
 # 视频输出VO分辨率，宽16字节对齐
 self.display_size=,16),display_size]
 # debug_mode模式
 self.debug_mode=debug_mode
 self.ocr_det=OCRDetectionApp(self.ocr_det_kmodel,model_input_size=self.det_input_size,mask_threshold=self.mask_threshold,box_threshold=self.box_threshold,rgb888p_size=self.rgb888p_size,display_size=self.display_size,debug_mode=0)
 self.ocr_rec=OCRRecognitionApp(self.ocr_rec_kmodel,model_input_size=self.rec_input_size,dict_path=self.dict_path,rgb888p_size=self.rgb888p_size,display_size=self.display_size)
 self.ocr_det.config_preprocess()

# run函数
def run(self,input_np):
 # 先进行OCR检测
 det_res=self.ocr_det.run(input_np)
 boxes=[]
 ocr_res=[]
 for det in det_res:
 # 对得到的每个检测框执行OCR识别
 self.ocr_rec.config_preprocess(input_image_size=.shape,det.shape],input_np=det)
 ocr_str=self.ocr_rec.run(det)
 ocr_res.append(ocr_str)
 boxes.append(det)
 gc.collect()
 return boxes,ocr_res

# 绘制OCR检测识别效果
def draw_result(self,pl,det_res,rec_res):
 pl.osd_img.clear()
 if det_res:
 # 循环绘制所有检测到的框
 for j in range(len(det_res)):
 # 将原图的坐标点转换成显示的坐标点，循环绘制四条直线，得到一个矩形框
 for i in range(4):
 x1 = det_res[(i * 2)] / self.rgb888p_size * self.display_size
 y1 = det_res[(i * 2 + 1)] / self.rgb888p_size * self.display_size
 x2 = det_res[((i + 1) * 2) % 8] / self.rgb888p_size * self.display_size
 y2 = det_res[((i + 1) * 2 + 1) % 8] / self.rgb888p_size * self.display_size
 pl.osd_img.draw_line((int(x1), int(y1), int(x2), int(y2)), color=(255, 0, 0, 255),thickness=5)
 pl.osd_img.draw_string_advanced(int(x1),int(y1),32,rec_res,color=(0,0,255))

if __name__=="__main__":
# 显示模式，默认"hdmi",可以选择"hdmi"和"lcd"
display_mode="lcd"
if display_mode=="hdmi":
 display_size=
else:
 display_size=
# OCR检测模型路径
ocr_det_kmodel_path="/sdcard/app/tests/kmodel/ocr_det_int16.kmodel"
# OCR识别模型路径
ocr_rec_kmodel_path="/sdcard/app/tests/kmodel/ocr_rec_int16.kmodel"
# 其他参数
dict_path="/sdcard/app/tests/utils/dict.txt"
rgb888p_size=
ocr_det_input_size=
ocr_rec_input_size=
mask_threshold=0.25
box_threshold=0.3

# 初始化PipeLine，只关注传给AI的图像分辨率，显示的分辨率
pl=PipeLine(rgb888p_size=rgb888p_size,display_size=display_size,display_mode=display_mode)
pl.create()
ocr=OCRDetRec(ocr_det_kmodel_path,ocr_rec_kmodel_path,det_input_size=ocr_det_input_size,rec_input_size=ocr_rec_input_size,dict_path=dict_path,mask_threshold=mask_threshold,box_threshold=box_threshold,rgb888p_size=rgb888p_size,display_size=display_size)

clock = time.clock()

try:
 while True:

 os.exitpoint()

 clock.tick()

 img=pl.get_frame() # 获取当前帧
 det_res,rec_res=ocr.run(img) # 推理当前帧
 ocr.draw_result(pl,det_res,rec_res) # 绘制当前帧推理结果
 print(det_res,rec_res) # 打印结果
 pl.show_image() # 展示当前帧推理结果
 gc.collect()

 print(clock.fps()) #打印帧率

except Exception as e:
 sys.print_exception(e)
finally:
 ocr.ocr_det.deinit()
 ocr.ocr_rec.deinit()
 pl.destroy()</code></pre>

    实验结果：

  

    某次结果, dtype=float32)] ['01\u79d1\u6280']，['01\u79d1\u6280']为识别结果，“\u79d1\u6280”为“科技”的Unicode编码，识别正确。

5、物体检测

    物体检测，是机器视觉里面非常典型的应用。要实现的就是将一幅图片里面的各种物体检测出来，然后跟已知模型做比较从而判断物体是什么。

    例程基于YOLOv8n, 支持识别80种物体。

    ["person", "bicycle", "car", "motorcycle", "airplane", "bus", "train", "truck", "boat", "traffic light", "fire hydrant", "stop sign", "parking meter", "bench", "bird", "cat", "dog", "horse", "sheep", "cow", "elephant", "bear", "zebra", "giraffe", "backpack", "umbrella", "handbag", "tie", "suitcase", "frisbee", "skis", "snowboard", "sports ball", "kite", "baseball bat", "baseball glove", "skateboard", "surfboard", "tennis racket", "bottle", "wine glass", "cup", "fork", "knife", "spoon", "bowl", "banana", "apple", "sandwich", "orange", "broccoli", "carrot", "hot dog", "pizza", "donut", "cake", "chair", "couch", "potted plant", "bed", "dining table", "toilet", "tv", "laptop", "mouse", "remote", "keyboard", "cell phone", "microwave", "oven", "toaster", "sink", "refrigerator", "book", "clock", "vase", "scissors", "teddy bear", "hair drier", "toothbrush"]

    [“人”、“自行车”、“汽车”、“摩托车”、“飞机”、“公共汽车”、“火车”、“卡车”、“船”、“交通灯”、“消防栓”、“停车标志”、“停车收费表”、“长凳”、“鸟”、“猫”、“狗”、“马”、“羊”、“牛”、“大象”、“熊”、“斑马”、“长颈鹿”、“背包”、“雨伞”、“手提包”、“领带”、“手提箱”、“飞盘”、“滑雪板”、“滑雪板”、“运动球”、“风筝”、“棒球棒”、“棒球手套”、“滑板”、“冲浪板”、“网球拍”、“瓶子”、“酒杯”、“杯子”、“叉子”、“刀子”、“勺子”、“碗”、“香蕉”、“苹果”、“三明治”、“橙子”、“西兰花”、“胡萝卜”、“热狗”、“披萨”、“甜甜圈”、“蛋糕”、“椅子”、“沙发“盆栽”、“床”、“餐桌”、“马桶”、“电视”、“笔记本电脑”、“鼠标”、“遥控器”、“键盘”、“手机”、“微波炉”、“烤箱”、“烤面包机”、“水槽”、“冰箱”、“书”、“钟表”、“花瓶”、“剪刀”、“泰迪熊”、“吹风机”、“牙刷”]

    具体编程思路如下：

  

    自定义YOLOv8检测类

    初始化（__init__）：

       设置模型路径、类别标签、模型输入尺寸、最大检测框数量、置信度阈值、NMS（非极大值抑制）阈值、RGB图像尺寸和显示尺寸。

       初始化Ai2d实例，用于实现模型预处理。

    预处理配置（config_preprocess）：

       配置Ai2d的预处理操作，这里使用了缩放（resize）操作来调整输入图像的尺寸以匹配模型的输入要求。

    后处理（postprocess）：

       对模型的推理结果进行后处理，包括转换输出格式、应用置信度阈值、执行NMS以及限制最大检测框数量。

    绘制结果（draw_result）：

       将检测结果绘制到图像上，包括绘制检测框和类别标签。

    非极大值抑制（nms）：

       实现NMS算法，用于去除重叠的检测框，提高检测的准确性。

    获取颜色（get_color）：

       根据检测到的物体类别索引，返回预设的颜色值，用于绘制不同类别的检测框。

    主函数的思路：

    设置显示模式和尺寸：

       根据选择的显示模式（HDMI或LCD），设置显示尺寸。

    初始化模型和参数：

      设置YOLOv8模型的路径、类别标签、置信度阈值、NMS阈值和最大检测框数量。

    创建PipeLine实例：

      初始化PipeLine，管理图像的获取和显示。

    初始化YOLOv8检测实例：

       创建ObjectDetectionApp类的实例，并配置预处理操作。

    主循环：

       在一个无限循环中，不断获取当前帧图像，进行物体检测，绘制结果，并显示。

       使用clock对象来计算和打印帧率。

    异常处理：

       捕获异常，打印异常信息，并在退出前释放相关资源。

参考代码如下：

<pre>
<code class="language-python">'''
实验名称：物体检测（基于yolov8n）
实验平台：01Studio CanMV K230
教程：wiki.01studio.cc
'''

from libs.PipeLine import PipeLine, ScopedTiming
from libs.AIBase import AIBase
from libs.AI2D import Ai2d
import os
import ujson
from media.media import *
from time import *
import nncase_runtime as nn
import ulab.numpy as np
import time
import utime
import image
import random
import gc
import sys
import aidemo

# 自定义YOLOv8检测类
class ObjectDetectionApp(AIBase):
def __init__(self,kmodel_path,labels,model_input_size,max_boxes_num,confidence_threshold=0.5,nms_threshold=0.2,rgb888p_size=,display_size=,debug_mode=0):
 super().__init__(kmodel_path,model_input_size,rgb888p_size,debug_mode)
 self.kmodel_path=kmodel_path
 self.labels=labels
 # 模型输入分辨率
 self.model_input_size=model_input_size
 # 阈值设置
 self.confidence_threshold=confidence_threshold
 self.nms_threshold=nms_threshold
 self.max_boxes_num=max_boxes_num
 # sensor给到AI的图像分辨率
 self.rgb888p_size=,16),rgb888p_size]
 # 显示分辨率
 self.display_size=,16),display_size]
 self.debug_mode=debug_mode
 # 检测框预置颜色值
 self.color_four=[(255, 220, 20, 60), (255, 119, 11, 32), (255, 0, 0, 142), (255, 0, 0, 230),
 (255, 106, 0, 228), (255, 0, 60, 100), (255, 0, 80, 100), (255, 0, 0, 70),
 (255, 0, 0, 192), (255, 250, 170, 30), (255, 100, 170, 30), (255, 220, 220, 0),
 (255, 175, 116, 175), (255, 250, 0, 30), (255, 165, 42, 42), (255, 255, 77, 255),
 (255, 0, 226, 252), (255, 182, 182, 255), (255, 0, 82, 0), (255, 120, 166, 157)]
 # 宽高缩放比例
 self.x_factor = float(self.rgb888p_size)/self.model_input_size
 self.y_factor = float(self.rgb888p_size)/self.model_input_size
 # Ai2d实例，用于实现模型预处理
 self.ai2d=Ai2d(debug_mode)
 # 设置Ai2d的输入输出格式和类型
 self.ai2d.set_ai2d_dtype(nn.ai2d_format.NCHW_FMT,nn.ai2d_format.NCHW_FMT,np.uint8, np.uint8)

# 配置预处理操作，这里使用了resize，Ai2d支持crop/shift/pad/resize/affine，具体代码请打开/sdcard/app/libs/AI2D.py查看
def config_preprocess(self,input_image_size=None):
 with ScopedTiming("set preprocess config",self.debug_mode > 0):
 # 初始化ai2d预处理配置，默认为sensor给到AI的尺寸，您可以通过设置input_image_size自行修改输入尺寸
 ai2d_input_size=input_image_size if input_image_size else self.rgb888p_size
 self.ai2d.resize(nn.interp_method.tf_bilinear, nn.interp_mode.half_pixel)
 self.ai2d.build(,ai2d_input_size],,self.model_input_size])

# 自定义当前任务的后处理
def postprocess(self,results):
 with ScopedTiming("postprocess",self.debug_mode > 0):
 result=results
 result = result.reshape((result.shape * result.shape, result.shape))
 output_data = result.transpose()
 boxes_ori = output_data[:,0:4]
 scores_ori = output_data[:,4:]
 confs_ori = np.max(scores_ori,axis=-1)
 inds_ori = np.argmax(scores_ori,axis=-1)
 boxes,scores,inds = [],[],[]
 for i in range(len(boxes_ori)):
 if confs_ori > confidence_threshold:
 scores.append(confs_ori)
 inds.append(inds_ori)
 x = boxes_ori
 y = boxes_ori
 w = boxes_ori
 h = boxes_ori
 left = int((x - 0.5 * w) * self.x_factor)
 top = int((y - 0.5 * h) * self.y_factor)
 right = int((x + 0.5 * w) * self.x_factor)
 bottom = int((y + 0.5 * h) * self.y_factor)
 boxes.append()
 if len(boxes)==0:
 return []
 boxes = np.array(boxes)
 scores = np.array(scores)
 inds = np.array(inds)
 # NMS过程
 keep = self.nms(boxes,scores,nms_threshold)
 dets = np.concatenate((boxes, scores.reshape((len(boxes),1)), inds.reshape((len(boxes),1))), axis=1)
 dets_out = []
 for keep_i in keep:
 dets_out.append(dets)
 dets_out = np.array(dets_out)
 dets_out = dets_out[:self.max_boxes_num, :]
 return dets_out

# 绘制结果
def draw_result(self,pl,dets):
 with ScopedTiming("display_draw",self.debug_mode >0):
 if dets:
 pl.osd_img.clear()
 for det in dets:
 x1, y1, x2, y2 = map(lambda x: int(round(x, 0)), det[:4])
 x= x1*self.display_size // self.rgb888p_size
 y= y1*self.display_size // self.rgb888p_size
 w = (x2 - x1) * self.display_size // self.rgb888p_size
 h = (y2 - y1) * self.display_size // self.rgb888p_size
 pl.osd_img.draw_rectangle(x,y, w, h, color=self.get_color(int(det)),thickness=4)
 pl.osd_img.draw_string_advanced( x , y-50,32," " + self.labels)] + " " + str(round(det,2)) , color=self.get_color(int(det)))
 else:
 pl.osd_img.clear()

# 多目标检测非最大值抑制方法实现
def nms(self,boxes,scores,thresh):
 """Pure Python NMS baseline."""
 x1,y1,x2,y2 = boxes[:, 0],boxes[:, 1],boxes[:, 2],boxes[:, 3]
 areas = (x2 - x1 + 1) * (y2 - y1 + 1)
 order = np.argsort(scores,axis = 0)[::-1]
 keep = []
 while order.size > 0:
 i = order
 keep.append(i)
 new_x1,new_y1,new_x2,new_y2,new_areas = [],[],[],[],[]
 for order_i in order:
 new_x1.append(x1)
 new_x2.append(x2)
 new_y1.append(y1)
 new_y2.append(y2)
 new_areas.append(areas)
 new_x1 = np.array(new_x1)
 new_x2 = np.array(new_x2)
 new_y1 = np.array(new_y1)
 new_y2 = np.array(new_y2)
 xx1 = np.maximum(x1, new_x1)
 yy1 = np.maximum(y1, new_y1)
 xx2 = np.minimum(x2, new_x2)
 yy2 = np.minimum(y2, new_y2)
 w = np.maximum(0.0, xx2 - xx1 + 1)
 h = np.maximum(0.0, yy2 - yy1 + 1)
 inter = w * h
 new_areas = np.array(new_areas)
 ovr = inter / (areas + new_areas - inter)
 new_order = []
 for ovr_i,ind in enumerate(ovr):
 if ind < thresh:
 new_order.append(order)
 order = np.array(new_order,dtype=np.uint8)
 return keep

# 根据当前类别索引获取框的颜色
def get_color(self, x):
 idx=x%len(self.color_four)
 return self.color_four

if __name__=="__main__":
# 显示模式，默认"hdmi",可以选择"hdmi"和"lcd"
display_mode="lcd"
if display_mode=="hdmi":
 display_size=
else:
 display_size=
# 模型路径
kmodel_path="/sdcard/app/tests/kmodel/yolov8n_320.kmodel"
labels = ["person", "bicycle", "car", "motorcycle", "airplane", "bus", "train", "truck", "boat", "traffic light", "fire hydrant", "stop sign", "parking meter", "bench", "bird", "cat", "dog", "horse", "sheep", "cow", "elephant", "bear", "zebra", "giraffe", "backpack", "umbrella", "handbag", "tie", "suitcase", "frisbee", "skis", "snowboard", "sports ball", "kite", "baseball bat", "baseball glove", "skateboard", "surfboard", "tennis racket", "bottle", "wine glass", "cup", "fork", "knife", "spoon", "bowl", "banana", "apple", "sandwich", "orange", "broccoli", "carrot", "hot dog", "pizza", "donut", "cake", "chair", "couch", "potted plant", "bed", "dining table", "toilet", "tv", "laptop", "mouse", "remote", "keyboard", "cell phone", "microwave", "oven", "toaster", "sink", "refrigerator", "book", "clock", "vase", "scissors", "teddy bear", "hair drier", "toothbrush"]
# 其它参数设置
confidence_threshold = 0.2
nms_threshold = 0.2
max_boxes_num = 50
rgb888p_size=

# 初始化PipeLine
pl=PipeLine(rgb888p_size=rgb888p_size,display_size=display_size,display_mode=display_mode)
pl.create()
# 初始化自定义目标检测实例
ob_det=ObjectDetectionApp(kmodel_path,labels=labels,model_input_size=,max_boxes_num=max_boxes_num,confidence_threshold=confidence_threshold,nms_threshold=nms_threshold,rgb888p_size=rgb888p_size,display_size=display_size,debug_mode=0)
ob_det.config_preprocess()

clock = time.clock()

try:
 while True:

 os.exitpoint()

 clock.tick()

 img=pl.get_frame() # 获取当前帧数据
 res=ob_det.run(img) # 推理当前帧
 ob_det.draw_result(pl,res) # 绘制结果到PipeLine的osd图像
 print(res)# 打印当前结果
 pl.show_image() # 显示当前的绘制结果
 gc.collect()

 print(clock.fps()) #打印帧率

except Exception as e:
 sys.print_exception(e)
finally:
 ob_det.deinit()
 pl.destroy()</code></pre>

    实验结果：

    缓冲区显示各个物体的名称和置信度（可信度），可以看到准确率还是挺高的。

页: [1]

电子工程世界-论坛's Archiver

嘉楠K230AI开发板测评8--人脸3D网络、人体关键点、车牌识别、字符识别、物体识别