C#联合Openvino实现PP-TinyPose检测

最新推荐文章于 2024-01-04 11:05:45 发布
最新推荐文章于 2024-01-04 11:05:45 发布
阅读量338 收藏 1
点赞数
分类专栏： Paddle 文章标签： c# openvino python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43118684/article/details/128499044
版权

1、配置好paddlepaddle环境，详见PaddleDetection环境搭建测试

2、下载PaddleDetection源码，并配置好PaddleDetection环境，测试paddle运行正常

3、下载vs2019或vs2022

4、下载cmake，https://cmake.org/download/

5、安装opencv，https://opencv.org/releases/

6、以上这些都是构建项目的必须组件，现在开始openvino的安装
在这里插入图片描述
python下使用就直接PIP安装，安装Development Tools版本，如果是C++使用就安装runtime离线版本，后面C++内配置openvino需要用到runtime版本的dll和lib：
在这里插入图片描述
在这里插入图片描述
安装完成后，可以看到在C:\Program Files (x86)\Intel\openvino_2022.1.0.643文件夹中已经有相关的文件，python也可以把离线包内的Python包拷贝到conda环境使用，但建议还是直接Pip方便

7、在vs内配置好opencv和openvino的库，都一样配置好三个地方就行，用属性表配置方便，用release还是debug版本根据需要选择就行：
包含目录、库目录、附加依赖项
openvino：
在这里插入图片描述
在这里插入图片描述
opencv：
在这里插入图片描述
在这里插入图片描述

8.增加OpenVinoAPI.cpp文件，代码引用自https://mp.weixin.qq.com/s/gOoeMPeAcvMSeGVqToKWuQ

// OpenVINO C++ dll code for C#
// 该项目支持模型格式：
//   1. paddlepaddle飞桨模型(.pdmodel)
//   2. onnx中间格式(.onnx)
//   3. OpenVINO的IR格式(.xml)
// 针对该项目所使用测试网络：
//   1. PaddleClas 图像分类模型 花卉种类识别网络的(.pdmodel)、(.onnx)、(.xml)格式；
//   2. Paddledetection 目标检测模型 车辆识别网络的(.pdmodel)格式；
// ONLY support batchsize = 1


#include<time.h>

#include<iostream>
#include<map>
#include<string>
#include<vector>

#include "openvino/openvino.hpp"
#include "opencv2/opencv.hpp"
#include <opencv2/core/utils/logger.hpp>

#include<windows.h>

// @brief 将wchar_t*字符串指针转换为string字符串格式
// @param wchar 输入字符指针
// @return 转换出的string字符串 
std::string wchar_to_string(const wchar_t* wchar) {
    // 获取输入指针的长度
    int path_size = WideCharToMultiByte(CP_OEMCP, 0, wchar, wcslen(wchar), NULL, 0, NULL, NULL);
    char* chars = new char[path_size + 1];
    // 将双字节字符串转换成单字节字符串
    WideCharToMultiByte(CP_OEMCP, 0, wchar, wcslen(wchar), chars, path_size, NULL, NULL);
    chars[path_size] = '\0';
    std::string pattern = chars;
    delete chars; //释放内存
    return pattern;
}

// @brief 将图片的矩阵数据转换为opencv的mat数据
// @param data 图片矩阵
// @param size 图片矩阵长度
// @return 转换后的mat数据
cv::Mat data_to_mat(uchar* data, size_t size) {
    //将图片数组数据读取到容器中
    std::vector<uchar> buf;
    for (int i = 0; i < size; i++) {
        buf.push_back(*data);
        data++;
    }
    // 利用图片解码，将容器中的数据转换为mat类型
    return cv::imdecode(cv::Mat(buf), 1);
}

// @brief 对网络的输入为图片数据的节点进行赋值，实现图片数据输入网络
// @param input_tensor 输入节点的tensor
// @param inpt_image 输入图片数据
void fill_tensor_data_image(ov::Tensor& input_tensor, const cv::Mat& input_image) {
    // 获取输入节点要求的输入图片数据的大小
    ov::Shape tensor_shape = input_tensor.get_shape();
    const size_t width = tensor_shape[3]; // 要求输入图片数据的宽度
    const size_t height = tensor_shape[2]; // 要求输入图片数据的高度
    const size_t channels = tensor_shape[1]; // 要求输入图片数据的维度
    // 读取节点数据内存指针
    float* input_tensor_data = input_tensor.data<float>();
    // 将图片数据填充到网络中
    // 原有图片数据为 H、W、C 格式，输入要求的为 C、H、W 格式
    for (size_t c = 0; c < channels; c++) {
        for (size_t h = 0; h < height; h++) {
            for (size_t w = 0; w < width; w++) {
                input_tensor_data[c * width * height + h * width + w] = input_image.at<cv::Vec<float, 3>>(h, w)[c];
            }
        }
    }
}
// @brief 对网络的输入为fkloat数据的节点进行赋值，实现float数据输入网络
// @param input_tensor 输入节点的tensor
// @param input_data 输入数据数组
// @param data_size 输入数组长度
void fill_tensor_data_float(ov::Tensor& input_tensor, float* input_data, int data_size) {
    // 读取节点数据内存指针
    float* input_tensor_data = input_tensor.data<float>();
    // 将图片数据填充到网络中
    for (int i = 0; i < data_size; i++) {
        input_tensor_data[i] = input_data[i];
    }
}

// @brief 构建放射变换矩阵
// @param center 中心点
// @param input_size 输入尺寸
// @param rot 角度
// @param output_size 输出尺寸
// @param shift 
// @rrturn 变换矩阵
cv::Mat get_affine_transform(cv::Point center, cv::Size input_size, int rot, cv::Size output_size, cv::Point2f shift = cv::Point2f(0, 0)) {

    // 输入尺寸宽度
    int src_w = input_size.width;

    // 输出尺寸
    int dst_w = output_size.width;
    int dst_h = output_size.height;

    // 旋转角度
    float rot_rad = 3.1715926f * rot / 180.0;
    int pt = (int)src_w * -0.5;
    float sn = std::sin(rot_rad);
    float cs = std::cos(rot_rad);

    cv::Point2f src_dir(-1.0 * pt * sn, pt * cs);
    cv::Point2f dst_dir(0.0, dst_w * -0.5);
    // 输入三个点
    cv::Point2f src[3];
    src[0] = cv::Point2f(center.x + input_size.width * shift.x, center.y + input_size.height * shift.y);
    src[1] = cv::Point2f(center.x + src_dir.x + input_size.width * shift.x, center.y + src_dir.y + input_size.height * shift.y);
    cv::Point2f direction = src[0] - src[1];
    src[2] = cv::Point2f(src[1].x - direction.y, src[1].y - direction.x);
    // 输出三个点
    cv::Point2f dst[3];
    dst[0] = cv::Point2f(dst_w * 0.5, dst_h * 0.5);
    dst[1] = cv::Point2f(dst_w * 0.5 + dst_dir.x, dst_h * 0.5 + dst_dir.y);
    direction = dst[0] - dst[1];
    dst[2] = cv::Point2f(dst[1].x - direction.y, dst[1].y - direction.x);

    return cv::getAffineTransform(src, dst);

}


// @brief 推理核心结构体
typedef struct openvino_core {
    ov::Core core; // core对象
    std::shared_ptr<ov::Model> model_ptr; // 读取模型指针
    ov::CompiledModel compiled_model; // 模型加载到设备对象
    ov::InferRequest infer_request; // 推理请求对象
} CoreStruct;

extern "C" __declspec(dllexport) int __stdcall test_add(int a, int b) {
    return a + b;
}


// @brief 初始化openvino核心结构体，读取本地推理模型，将模型加载到设备，并创建推理请求
// @note 可支持的推理模型的格式为：(.pdmodel)、(.onnx)、(.xml)格式
// @note 可支持设备选择（AUTO）自动选择、（CPU）处理器、（GPU）显卡
// @param model_file_wchar 推理模型本地地址
// @param device_name_wchar 加载设备名称
// @return 推理核心结构体指针
extern "C" __declspec(dllexport) void* __stdcall core_init(const wchar_t* model_file_wchar, const wchar_t* device_name_wchar) {
    cv::utils::logging::setLogLevel(cv::utils::logging::LOG_LEVEL_ERROR);

    //读取接口输入参数
    std::string model_file_path = wchar_to_string(model_file_wchar);// 推理模型本地地址
    std::string device_name = wchar_to_string(device_name_wchar);// 加载设备名称
    // 初始化推理核心
    CoreStruct* p = new CoreStruct(); // 创建推理引擎指针
    p->model_ptr = p->core.read_model(model_file_path); // 读取推理模型
    p->compiled_model = p->core.compile_model(p->model_ptr, "CPU"); // 将模型加载到设备
    p->infer_request = p->compiled_model.create_infer_request(); // 创建推理请求

    return (void*)p;
}


// @brief 为输入为图片数据的tensor设置新形状，如果新的总大小大于前一个，则取消之前的设置
// @param inference_engine 推理核心指针
// @param input_node_name_wchar 输入节点名
// @param input_size 输入形状数据数组
// @return 推理核心结构体指针
extern "C"  __declspec(dllexport) void* __stdcall set_input_image_sharp(void* core_ptr, const wchar_t* input_node_name_wchar, size_t * input_size) {
    // 读取推理模型地址
    CoreStruct* p = (CoreStruct*)core_ptr;
    std::string input_node_name = wchar_to_string(input_node_name_wchar);
    // 获取指定节点的tensor
    ov::Tensor input_image_tensor = p->infer_request.get_tensor(input_node_name);
    // 设置节点输入数据的形状
    input_image_tensor.set_shape({ input_size[0],input_size[1],input_size[2],input_size[3] });
    return (void*)p;
}

// @brief 为输入为float数据的tensor设置新形状，如果新的总大小大于前一个，则取消之前的设置
// @param inference_engine 推理核心指针
// @param input_node_name_wchar 输入节点名
// @param input_size 输入形状数据数组
// @return 推理核心结构体指针
extern "C"  __declspec(dllexport) void* __stdcall set_input_data_sharp(void* core_ptr, const wchar_t* input_node_name_wchar, size_t * input_size) {
    // 读取推理模型地址
    CoreStruct* p = (CoreStruct*)core_ptr;
    std::string input_node_name = wchar_to_string(input_node_name_wchar);
    // 获取指定节点的tensor
    ov::Tensor input_image_tensor = p->infer_request.get_tensor(input_node_name);
    // 重新设置数据长度
    input_image_tensor.set_shape({ input_size[0] , input_size[1] });
    return (void*)p;
}

// @brief 将图片数据加载到tensor中的数据内存上
// @param inference_engine 推理核心指针
// @param input_node_name_wchar 输入节点名
// @param image_data 输入图片数据矩阵
// @param image_size 图片矩阵长度
// @return 推理核心结构体指针
extern "C"  __declspec(dllexport) void* __stdcall load_image_input_data(void* core_ptr, const wchar_t* input_node_name_wchar, uchar * image_data, size_t image_size, int type) {
    // 读取推理模型地址
    CoreStruct* p = (CoreStruct*)core_ptr;
    std::string input_node_name = wchar_to_string(input_node_name_wchar);
    // 获取输入节点tensor
    ov::Tensor input_image_tensor = p->infer_request.get_tensor(input_node_name);
    int input_H = input_image_tensor.get_shape()[2]; //获得"image"节点的Height
    int input_W = input_image_tensor.get_shape()[3]; //获得"image"节点的Width

    // 对输入图片进行预处理
    cv::Mat input_image = data_to_mat(image_data, image_size); // 读取输入图片
    cv::Mat blob_image;
    cv::cvtColor(input_image, blob_image, cv::COLOR_BGR2RGB); // 将图片通道由 BGR 转为 RGB

    if (type == 0) {
        // 对输入图片按照tensor输入要求进行缩放
        cv::resize(blob_image, blob_image, cv::Size(input_W, input_H), 0, 0, cv::INTER_LINEAR);
        // 图像数据归一化，减均值mean，除以方差std
        // PaddleDetection模型使用imagenet数据集的均值 Mean = [0.485, 0.456, 0.406]和方差 std = [0.229, 0.224, 0.225]
        std::vector<float> mean_values{ 0.485 * 255, 0.456 * 255, 0.406 * 255 };
        std::vector<float> std_values{ 0.229 * 255, 0.224 * 255, 0.225 * 255 };
        std::vector<cv::Mat> rgb_channels(3);
        cv::split(blob_image, rgb_channels); // 分离图片数据通道
        for (auto i = 0; i < rgb_channels.size(); i++) {
            //分通道依此对每一个通道数据进行归一化处理
            rgb_channels[i].convertTo(rgb_channels[i], CV_32FC1, 1.0 / std_values[i], (0.0 - mean_values[i]) / std_values[i]);
        }
        cv::merge(rgb_channels, blob_image); // 合并图片数据通道
    }
    else if (type == 1) {
        // 对输入图片按照tensor输入要求进行缩放
        cv::resize(blob_image, blob_image, cv::Size(input_W, input_H), 0, 0, cv::INTER_LINEAR);
        // 图像数据归一化
        std::vector<float> mean_values{ 0.5 * 255, 0.5 * 255, 0.5 * 255 };
        std::vector<float> std_values{ 0.5 * 255, 0.5 * 255, 0.5 * 255 };
        std::vector<cv::Mat> rgb_channels(3);
        cv::split(blob_image, rgb_channels); // 分离图片数据通道
        for (auto i = 0; i < rgb_channels.size(); i++) {
            //分通道依此对每一个通道数据进行归一化处理
            rgb_channels[i].convertTo(rgb_channels[i], CV_32FC1, 1.0 / std_values[i], (0.0 - mean_values[i]) / std_values[i]);
        }
        cv::merge(rgb_channels, blob_image); // 合并图片数据通道
    }
    else if (type == 2) {
        // 获取仿射变换信息
        cv::Point center(blob_image.cols / 2, blob_image.rows / 2); // 变换中心
        cv::Size input_size(blob_image.cols, blob_image.rows); // 输入尺寸
        int rot = 0; // 角度
        cv::Size output_size(input_W, input_H); // 输出尺寸

        // 获取仿射变换矩阵
        cv::Mat warp_mat(2, 3, CV_32FC1);
        warp_mat = get_affine_transform(center, input_size, rot, output_size);
        // 仿射变化
        cv::warpAffine(blob_image, blob_image, warp_mat, output_size, cv::INTER_LINEAR);
        // 图像数据归一化
        std::vector<float> mean_values{ 0.485 * 255, 0.456 * 255, 0.406 * 255 };
        std::vector<float> std_values{ 0.229 * 255, 0.224 * 255, 0.225 * 255 };
        std::vector<cv::Mat> rgb_channels(3);
        cv::split(blob_image, rgb_channels); // 分离图片数据通道
        for (auto i = 0; i < rgb_channels.size(); i++) {
            //分通道依此对每一个通道数据进行归一化处理
            rgb_channels[i].convertTo(rgb_channels[i], CV_32FC1, 1.0 / std_values[i], (0.0 - mean_values[i]) / std_values[i]);
        }
        cv::merge(rgb_channels, blob_image); // 合并图片数据通道
    }
    // 将图片数据填充到tensor数据内存中
    fill_tensor_data_image(input_image_tensor, blob_image);

    return (void*)p;
}
// @brief 将其他数据加载到tensor中的数据内存上
// @param inference_engine 推理核心指针
// @param input_node_name_wchar 输入节点名
// @param input_data 输入数据数组
// @return 推理核心结构体指针
extern "C"  __declspec(dllexport) void* __stdcall load_input_data(void* core_ptr, const wchar_t* input_node_name_wchar, float* input_data) {
    // 读取推理模型地址
    CoreStruct* p = (CoreStruct*)core_ptr;
    std::string input_node_name = wchar_to_string(input_node_name_wchar);
    // 读取指定节点tensor
    ov::Tensor input_image_tensor = p->infer_request.get_tensor(input_node_name);
    int input_size = input_image_tensor.get_shape()[1]; //获得输入节点的长度
    // 将数据填充到tensor数据内存上
    fill_tensor_data_float(input_image_tensor, input_data, input_size);

    return (void*)p;
}

// @brief 对加载好的推理模型进行推理
// @param inference_engine 推理核心指针
// @return 推理核心结构体指针
extern "C"  __declspec(dllexport) void* __stdcall core_infer(void* core_ptr) {
    // 读取推理模型地址
    CoreStruct* p = (CoreStruct*)core_ptr;
    // 模型预测
    p->infer_request.infer();

    return (void*)p;
}

// @brief 查询float类型的推理结果
// @param inference_engine 推理核心指针
// @param output_node_name_wchar 输出节点名
// @param data_size 数据长度
// @param [out]  inference_result 推理结果数组
extern "C"  __declspec(dllexport) void __stdcall read_infer_result_F32(void* core_ptr, const wchar_t* output_node_name_wchar, int data_size, float* infer_result) {
    // 读取推理模型地址
    CoreStruct* p = (CoreStruct*)core_ptr;
    std::string output_node_name = wchar_to_string(output_node_name_wchar);
    // 读取指定节点的tensor
    const ov::Tensor& output_tensor = p->infer_request.get_tensor(output_node_name);
    // std::cout << " output_tensor.get_shape() ：" << output_tensor.get_shape() << std::endl;
    // 获取网络节点数据地址
    const float* results = output_tensor.data<const float>();
    // 将输出结果复制到输出地址指针中
    for (int i = 0; i < data_size; i++) {
        *infer_result = results[i];
        infer_result++;
    }
}

// @brief 查询int类型的推理结果
// @param inference_engine 推理核心指针
// @param output_node_name_wchar 输出节点名
// @param data_size 数据长度
// @param [out]  inference_result 推理结果数组
extern "C"  __declspec(dllexport) void __stdcall read_infer_result_I32(void* core_ptr, const wchar_t* output_node_name_wchar, int data_size, int* infer_result) {
    // 读取推理模型地址
    CoreStruct* p = (CoreStruct*)core_ptr;
    std::string output_node_name = wchar_to_string(output_node_name_wchar);
    // 读取指定节点的tensor
    const ov::Tensor& output_tensor = p->infer_request.get_tensor(output_node_name);
    std::cout << " output_tensor.get_shape() ：" << output_tensor.get_shape() << std::endl;
    // 获取网络节点数据地址
    const int* results = output_tensor.data<const int>();
    // 将输出结果赋值到输出地址指针中
    for (int i = 0; i < data_size; i++) {
        *infer_result = results[i];
        infer_result++;
    }
}

// @brief 查询long long类型的推理结果
// @param inference_engine 推理核心指针
// @param output_node_name_wchar 输出节点名
// @param data_size 数据长度
// @param [out]  inference_result 推理结果数组
extern "C"  __declspec(dllexport) void __stdcall read_infer_result_I64(void* core_ptr, const wchar_t* output_node_name_wchar, int data_size, long long* infer_result) {
    // 读取推理模型地址
    CoreStruct* p = (CoreStruct*)core_ptr;
    std::string output_node_name = wchar_to_string(output_node_name_wchar);
    // 读取指定节点的tensor
    const ov::Tensor& output_tensor = p->infer_request.get_tensor(output_node_name);
    // std::cout << " output_tensor.get_shape() ：" << output_tensor.get_shape() << std::endl;
    // 获取网络节点数据地址
    const long long* results = output_tensor.data<const long long>();
    // 将输出结果赋值到输出地址指针中
    for (int i = 0; i < data_size; i++) {
        *infer_result = results[i];
        infer_result++;
    }
}


// @brief 删除推理核心结构体指针，释放占用内存
// @param inference_engine 推理核心指针
extern "C"  __declspec(dllexport) void __stdcall core_delet(void* core_ptr) {
    //读取推理模型地址
    CoreStruct* p = (CoreStruct*)core_ptr;
    // 删除占用内存
    delete p;
}
LYpokerface
关注
专栏目录
openvino_insightface_fp32人脸识别模型
11-22
openvino_insightface_fp32人脸识别模型，有resnet50的IR文件，FP32精度，2020.4版本转化
Intel OpenVINO MFC例程及教程
04-13
Intel OpenVINO MFC例程及教程，支持人脸识别、头部姿态、表情识别、年龄性别识别多种模型，全部源码及Step by Step教程。
C#平台调用OpenVINOTM部署PP-TinyPose人体关键点识别模型
02-29
基于OpenVINOTM模型推理库，在C#语言下，调用封装的OpenVINOTM动态链接库，部署推理PP-TinyPose人体关键点识别模型，实现了在C#平台调用OpenVINOTM部署PP-TinyPose人体关键点识别模型 项目介绍  该项目基于OpenVINOTM模型推理库，在C#语言下，调用封装的OpenVINOTM动态链接库，部署推理PP-TinyPose人体关键点识别模型，实现了在C#平台调用OpenVINOTM部署PP-TinyPose人体关键点识别模型。  如图所示，PaddlePaddle向我们提供了完整的人体关键点识别解决方案，主要包括行人检测以及关键点检测两部分。人体检测主要是实现行人位置检测，在多人关键点识别任务中，可以做行人区域划分等工作，此处飞桨提供了轻量级PicoDet行人识别模型，用于行人区域识别。关键点识别采用的是基于Lite-HRNet骨干网络的PP-TinyPose模型，并增加了DARK关键点矫正算法，使模型关键点识别更加精准；且该网络至此多bath_size推理，可以实现同时多图片推理运算。
C#利用openvino部署PP-TinyPose人体姿态识别
FL1623863129的博客
01-04 1578
而PP-TinyPose的出世彻底打破了这个僵局，采用Top-Down的方式，先应用3.3M、150FPS的超轻量检测网络。完成一系列针对性的优化，从而对小目标进行关键点检测时，依然能保持同样的精度与速。更特别的是，PP-TinyPose还能同时实现。检测出人体，再用基于Lite-HRNet的移动端优化模型，检测对应关键点，由此确保关键点检测的。，同时扩大数据集，减小输入尺寸，预处理与后处理加入AID、UDP和DARK等策略，保证模型的。，不仅比其他类似实现速度更快，精度更是提升了130%。
C#利用openvino部署PP-TinyPose人体姿态识别源码
01-04
【测试环境】 vs2019 netframework4.7.2或者netframework4.8 opencvsharp4.8.0 无需额外安装openvino运行库即可直接运行 【博客地址】 blog.csdn.net/FL1623863129/article/details/135381562 【视频演示】 bilibili.com/video/BV1vC4y1e7QL/
[C#]C# OpenVINO部署yolov8-pose姿态估计模型
FL1623863129的博客
01-04 707
同时，为了实现人体姿态点的检测和估计，Yolov8-Pose在输出层上引入了关键点检测的任务分支。人体姿势可以看作是由多个关键点组成的，例如头部、肩膀、手肘、手腕等。Yolov8-Pose算法通过在Yolov8的基础上增加额外的关键点检测层，来实现对这些关键点的检测和定位。该算法在Yolov8的基础上引入了姿势估计模块，通过联合检测和姿势估计的方式来实现准确的姿势检测。通过以上原理，Yolov8-Pose算法能够在保持检测速度的同时，实现对人体姿势的准确检测，从而在人体姿态估计领域具有一定的应用价值。
C# OpenVINO Yolov8-OBB 旋转目标检测 源码
02-27
【C# OpenVINO Yolov8-OBB 旋转目标检测 源码】是一个基于C#编程语言的项目，利用Intel的OpenVINO工具包实现了Yolov8的优化版——Yolov8-OBB（Oriented Bound Box，即带有角度信息的边界框）的目标检测算法。...
C#实现基于Csharp和OpenVINO部署PP-Human 模型
最新发布
02-29
通过以上步骤，你将能够成功地在C#环境中利用OpenVINO部署PP-Human模型，实现实时的人体关键点检测。记住，实践是检验理论的最好方式，尝试将这些知识应用到实际项目中，不断优化和改进，你会对深度学习和计算机视觉...
C# OpenVINO 直接读取百度模型实现图片旋转角度检测 源码
12-16
在本文中，我们将深入探讨如何使用C#编程语言与Intel的OpenVINO工具包结合，直接读取百度的模型来实现图像旋转角度检测。OpenVINO（Open Visual Inference and Neural Network Optimization）是一个强大的框架，它...
c#调用目标检测模型
qq_42607586的博客
09-27 608
之前花了两个星期实现c#部署图像分类程序，我是小白，啥也不会，只能慢慢摸索，如果这次也能部署成功，我就写博客，把我遇到的坑全部记录下来哈哈哈哈哈。
C# OpenVinoSharp PP-TinyPose 人体姿态识别
.NET 人工智能实践
09-06 1038
C# OpenVinoSharp PP-TinyPose 人体姿态识别
C# OpenVinoSharp PP-TinyPose.rar 完整Demo 自带模型，可直接运行
09-07
C# OpenVinoSharp PP-TinyPose.rar 完整Demo 自带模型，可直接运行 VS2022+.net 4.8+openvino_2023.0.1.11005+opencv4 博客地址： https://lw112190.blog.csdn.net/article/details/132720816
C#人脸识别考勤系统源码，内含语音播报
04-09
通过Usb摄像头采集人脸信息，在规定的时间段内进行考勤，超过时间段无法考勤，并伴语音提示。
OpenVINO2020.4 人脸分析系列（一）：人脸检测C++ Demo
zxrc的博客
10-19 1074
Opnvino2020.4版 人脸检测 OpenVINO2020.4版人脸检测Demo： 提示：这里可以添加学习目标 例如：一周掌握 Java 入门知识 学习内容： 提示：这里可以添加要学的内容 例如： 1、 搭建 Java 开发环境 2、 掌握 Java 基本语法 3、 掌握条件语句 4、 掌握循环语句 学习时间： 提示：这里可以添加计划学习的时间 例如： 1、 周一至周五晚上 7 点—晚上9点 2、 周六上午 9 点-上午 11 点 3、 周日下午 3 点-下午 6 点 学习产出： 提示：这里统计
【openvino+树莓派】实现实时摄像头人脸检测
dujuancao11的博客
03-02 4801
目录 参考步骤 人脸检测py代码 图片形式 摄像头实时 树莓派+openvino人脸检测实时效果 openvino 树莓派 人脸实时检测测试效果_哔哩哔哩_bilibili 参考步骤 Openvino：安装、部署。（可参考以下文档，验证不建议参考） 树莓派+神经计算棒2部署Openvino的human_pose_estimation_demo实例_hwxhxyz1998403的博客-CSDN博客_openpose 树莓派 树莓派4B使用OpenVINO部署人体关键点检测...
C# 人脸检测 人脸比对 活体检测 口罩检测 年龄预测 性别预测 眼睛状态检测
.NET 人工智能实践
03-08 1471
C# 人脸检测 人脸比对 活体检测 口罩检测 年龄预测 性别预测 眼睛状态检测
openvino系列教程之人脸检测 mobilenetv2
整理ing
10-18 634
openvino系列教程之人脸检测 mobilenetv2
C# 超简单的离线人脸识别库
寒冰屋的专栏
07-11 3225
ViewFaceCore 是一个使用 C# 开发的超简单的离线人脸识别库。( 基于 SeetaFace6 )，多平台支持， 开源、免费、跨平台 (win/linux)。 支持的 .NET 版本, .NET Framework， .NET Standard, .NET / .NET Core 。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值