Detección de punta y tapa del lápiz 4: C++ implementa un algoritmo de detección de punta y tapa del lápiz (código fuente incluido, pero detección en tiempo real)

Enterprise 2023-12-17 14:31:53 views: null

Detección de punta y tapa del lápiz 4: C++ implementa un algoritmo de detección de punta y tapa del lápiz (código fuente incluido, pero detección en tiempo real)

Tabla de contenido

Detección de punta y tapa del lápiz 4: C++ implementa un algoritmo de detección de punta y tapa del lápiz (código fuente incluido, pero detección en tiempo real)

1.Introducción al proyecto

 2. Método de detección del punto clave de la punta y la tapa del lápiz

(1) Método de arriba hacia abajo (de arriba hacia abajo)

(2) Método de abajo hacia arriba (de abajo hacia arriba):

3. Modelo de detección de puntos clave de punta y tapa de bolígrafo

(1) Entrenamiento del modelo de detección de puntos clave de punta y tapa de lápiz

(2) Convertir el modelo Pytorch al modelo ONNX

(3) Convertir el modelo ONNX al modelo TNN

4. Implementación de C/C++ de detección de puntos clave de punta y tapa de lápiz

(1) Estructura del proyecto

(2) Configurar el entorno de desarrollo (OpenCV+OpenCL+base-utils+TNN)

(3) Implementar el modelo TNN

(4) Configuración de CMake

(5) código fuente principal

(6) Compilación y operación del código fuente

(7) Efecto de prueba de demostración 

5. Descarga del código fuente del proyecto

6. Edición especial: Detección de la punta del dedo del lápiz

1.Introducción al proyecto

Actualmente, en el campo de la educación inteligente con IA, existe un producto educativo relativamente popular, a saber,Lectura de la punta de los dedos o<. Función i =3>Lectura de la punta del lápiz, su algoritmo principal es obtener la posición de la punta del lápiz o del dedo mediante un método de aprendizaje profundo, reconocer el texto mediante OCR y finalmente convertir el texto en voz. Entre ellos, los algoritmos OCR y TTS han sido muy maduros, y también hay algunos proyectos de código abierto para métodos de detección de la punta del dedo o de la punta del lápiz que se pueden implementar como referencia. Este proyecto implementaráalgoritmo de detección de puntos clave de punta y tapa de lápiz, en el que se utiliza el modelo YOLOv5 para implementar la detección de manos (detección de objetivos de lápiz portátil) , utilizando HRNet, LiteHRNet y el modelo Mobilenet-v2 implementa la detección de puntos clave de la punta y la tapa del lápiz. El proyecto se divide en varios capítulos, como anotación de datos, entrenamiento de modelos e implementación de Android. Este artículo es uno de una serie de artículos sobre el proyecto "Detección de puntas y tapas de bolígrafos<". a i=8>" C++ implementa un algoritmo de detección de puntas y tapas de lápiz; para facilitar la ingeniería de modelos posterior y la implementación de la plataforma Android, el proyecto admite alta precisión Modelo de detección HRNet, modelo liviano LiteHRNet y entrenamiento y prueba de modelos Mobilenet, y proporciona múltiples versiones de Python/C++/Android;

El modelo liviano Mobilenet-v2 puede lograr resultados de detección en tiempo real en teléfonos Android normales. La CPU (4 subprocesos) tarda aproximadamente 50 ms y la GPU tarda aproximadamente 30 ms, lo que básicamente cumple con los requisitos de rendimiento de la empresa. La siguiente tabla muestra la cantidad de cálculo y la cantidad de parámetros de HRNet, así como los modelos livianos LiteHRNet y Mobilenet, así como su precisión de detección.

Modelo tamaño de entrada parámetros(M) GFLOP AP
HRNet-w32 192×192 28,48 millones 5734.05M 0.8418
LiteHRNet18 192×192 1,10 millones 182,15M 0.7469
Mobilenet-v2 192×192 2,63 millones 529,25 millones 0.7531

Muéstralo primeroDetección de puntos clave de la punta y la tapa del lápizEfecto:

AndroidDetección de puntos clave de la punta y la tapa del lápizExperiencia de demostración de la APLICACIÓN (Descargar< a i= 4>):

https://download.csdn.net/download/guyuealian/88535143

  

[Respete la originalidad, indique la fuente al reimprimir]https://blog.csdn.net/guyuealian/article/details/134070516

Para ver más proyectos de la serie de artículos "Detección de puntas y capuchones de lápiz", consulte:

 2.Punta y tapa del lápizPuntos claveMétodo de detección

El objetivo de la punta y la tapa del lápiz es pequeño. Si la detección del objetivo se utiliza directamente, es difícil lograr una precisión de detección a nivel de píxeles. Generalmente se recomienda utilizar una solución similar a la detección de puntos clave del cuerpo humano. Actualmente existen dos métodos principales de puntos clave: uno es el método Top-Down (de arriba hacia abajo) y el otro es el < a i=3>Método ascendente(de abajo hacia arriba);

(1)De arriba hacia abajo(Jijijishita)Método

Separe la detección de la mano (el estado en que se sostiene el bolígrafo) y la detección del punto clave de la punta y la tapa del bolígrafo. Primero, realice la detección del objetivo de la mano en la imagen para localizar la posición de la mano; luego recorte cada imagen de la mano y luego calcule la clave puntos de la punta y la tapa del lápiz; los métodos de esta clase tienden a ser más lentos, pero tienen una mayor precisión en la estimación de la pose. En la actualidad, los modelos principales incluyen principalmente CPN, Hourglass, CPM, Alpha Pose, HRNet, etc.

(2)Abajo-arriba(Joshigejiji)Método:

Primero estime todos los puntos clave de la punta y la tapa del lápiz en la imagen y luego combínelos en instancias una por una mediante el método de agrupación; por lo tanto, este tipo de método suele ser más rápido y menos preciso al probar la inferencia. Un ejemplo típico es Open Pose, campeón de detección de puntos clave del cuerpo humano de COCO en 2016.

En términos generales, Top-Down tiene mayor precisión, mientras que Bottom-Up tiene mayor velocidad;Basado en investigaciones actuales En términos generales, el El método de arriba hacia abajo se ha estudiado más y su precisión es mayor que el método de abajo hacia arriba.

Este proyecto adoptaDe arriba hacia abajo(de arriba hacia abajo) Método, use el modelo YOLOv5 para implementar la detección de manos (detección de lápiz portátil) y use HRNet para detectar los puntos clave de la punta y la tapa del lápiz; también puede entenderse simplemente como usar YOLOv5 para ubicar el área donde Se sostiene el lápiz y luego se utiliza HRNet para detectar la punta del lápiz. Posicionamiento refinado de la tapa del lápiz.

Este proyecto está mejorado en base al HRNet de código abierto. Consulte GitHub para conocer el proyecto HRNet.

HRNet: https://github.com/leoxiaobin/deep-high-solving-net.pytorch

3. Modelo de detección de puntos clave de punta y tapa de bolígrafo

(1) Entrenamiento del modelo de detección de puntos clave de punta y tapa de lápiz

Este proyecto adoptaDe arriba hacia abajo(de arriba hacia abajo)Método, utilice el modelo YOLOv5 para implementar la detección de manos (detección de manos y bolígrafos) y mejore la implementación basada en HRNet de código abiertoDetección de puntos clave de punta y tapa del bolígrafo< a i=6>; Para facilitar la ingeniería de modelos posterior y la implementación de la plataforma Android, el proyecto admite la capacitación y prueba de modelos livianos LiteHRNet y Mobilenet, y proporciona múltiples versiones de Python/C++/Android< /span>; El modelo liviano Mobilenet-v2 puede lograr resultados de detección en tiempo real en teléfonos Android normales. La CPU (4 subprocesos) es de aproximadamente 50 ms y la GPU es de aproximadamente 30 ms, lo que básicamente cumple con los requisitos de rendimiento de el negocio

Esta publicación de blog comparte principalmente la versión C++ de la implementación del modelo. No incluye la versión Python del código de entrenamiento ni los conjuntos de datos relacionados. Acerca depunta y tapa del lápizclave Para conocer los métodos de entrenamiento de detección de puntos y las instrucciones del conjunto de datos, consulte:

Detección de punta y tapa del lápiz 2: Pytorch implementa un algoritmo de detección de punta y tapa del lápiz (incluido el código de entrenamiento y el conjunto de datos)

La siguiente tabla muestra la cantidad de cálculo y la cantidad de parámetros de HRNet, así como los modelos livianos LiteHRNet y Mobilenet, así como su precisión de detección AP; el modelo de detección de alta precisión HRNet-w32, AP puede alcanzar 0.8418, pero su cantidad de parámetros y la cantidad de cálculo son relativamente grandes, y no son adecuados para su implementación en el terminal móvil; LiteHRNet18 y Mobilenet-v2 tienen parámetros y cálculos relativamente pequeños, por lo que son adecuados para su implementación en el terminal móvil; aunque el cálculo teórico y las cantidades de parámetros de LiteHRNet18 son inferiores a los de Mobilenet-v2; en pruebas reales, se encontró que Mobilenet-v2 se ejecuta más rápido. El modelo liviano Mobilenet-v2 puede lograr resultados de detección en tiempo real en teléfonos Android normales. La CPU (4 subprocesos) tarda aproximadamente 50 ms y la GPU tarda aproximadamente 30 ms, lo que básicamente cumple con los requisitos de rendimiento de la empresa.

Modelo tamaño de entrada parámetros(M) GFLOP AP
HRNet-w32 192×192 28,48 millones 5734.05M 0.8418
LiteHRNet18 192×192 1,10 millones 182,15M 0.7469
Mobilenet-v2 192×192 2,63 millones 529,25 millones 0.7531

(2) Convertir el modelo Pytorch al modelo ONNX

Actualmente, existen muchos métodos de implementación para modelos CNN. Puede usar herramientas de implementación como TNN, MNN, NCNN y TensorRT. Yo uso TNN para la implementación de terminales C/C++. El proceso de implementación se puede dividir en cuatro pasos: Entrenar el modelo ->Convertir el modelo a un modelo ONNX ->Convertir el modelo ONNX a un modelo TNN ->Implementar C/C++ el modelo TNN.

Después de entrenar el modelo Pytorch, debemos convertir el modelo a un modelo ONNX para su posterior implementación.

  • El proyecto original proporciona un script de conversión, solo necesita modificar model_file para que sea la ruta de su modelo.
  •  convert_torch_to_onnx.py implementa el script para convertir el modelo Pytorch al modelo ONNX
python libs/convert_tools/convert_torch_to_onnx.py
"""
This code is used to convert the pytorch model into an onnx format model.
"""
import os
import torch.onnx
from pose.inference import PoseEstimation
from basetrainer.utils.converter import pytorch2onnx
 
 
def load_model(config_file, model_file, device="cuda:0"):
    pose = PoseEstimation(config_file, model_file, device=device)
    model = pose.model
    config = pose.config
    return model, config
 
 
def convert2onnx(config_file, model_file, device="cuda:0", onnx_type="kp"):
    """
    :param model_file:
    :param input_size:
    :param device:
    :param onnx_type:
    :return:
    """
    model, config = load_model(config_file, model_file, device=device)
    model = model.to(device)
    model.eval()
    model_name = os.path.basename(model_file)[:-len(".pth")]
    onnx_file = os.path.join(os.path.dirname(model_file), model_name + ".onnx")
    # dummy_input = torch.randn(1, 3, 240, 320).to("cuda")
    input_size = tuple(config.MODEL.IMAGE_SIZE)  # w,h
    input_shape = (1, 3, input_size[1], input_size[0])
    pytorch2onnx.convert2onnx(model,
                              input_shape=input_shape,
                              input_names=['input'],
                              output_names=['output'],
                              onnx_file=onnx_file,
                              opset_version=11)
 
 
if __name__ == "__main__":
    model_file = "../../work_space/hand/mobilenet_v2_21_192_192_custom_coco_20230928_065444_0934/model/best_model_153_0.7574.pth"
    config_file = "../../work_space/hand/mobilenet_v2_21_192_192_custom_coco_20230928_065444_0934/mobilenetv2_hand_192_192.yaml"
    convert2onnx(config_file, model_file)

(3) Convertir el modelo ONNX al modelo TNN

Actualmente, existen muchos métodos de implementación para modelos CNN. Puede usar herramientas de implementación como TNN, MNN, NCNN y TensorRT. Yo uso TNN para la implementación de terminales C/C++.

Herramienta de conversión TNN:

​​​​​

4. Implementación de C/C++ de detección de puntos clave de punta y tapa de lápiz

La herramienta de desarrollo IDE del proyecto utiliza CLion. Las bibliotecas dependientes relevantes incluyen principalmente OpenCV, base-utils, TNN y OpenCL (opcional). OpenCV debe estar instalado, OpenCL se usa para la aceleración del modelo, base-utils y TNN se han configurado y no necesita ser instalado;

El proyecto solo se prueba en Ubuntu 18.04. Configure usted mismo el entorno de desarrollo en el sistema Windows.

(1) Estructura del proyecto

​​

(2) Configurar el entorno de desarrollo (OpenCV+OpenCL+base-utils+TNN)

La herramienta de desarrollo IDE del proyecto utiliza CLion. Las bibliotecas dependientes relevantes incluyen principalmente OpenCV, base-utils, TNN y OpenCL (opcional). OpenCV debe estar instalado, OpenCL se usa para la aceleración del modelo, base-utils y TNN se han configurado y no necesita ser instalado;

El proyecto solo se prueba en Ubuntu 18.04, configúrelo y compílelo usted mismo en el sistema Windows.

  • Instalación de OpenCV: procesamiento de imágenes

El procesamiento de imágenes (como leer imágenes, recortar imágenes, etc.) requiere el uso de la biblioteca OpenCV para su procesamiento.

Tutorial de instalación:Instalación Ubuntu18.04 de opencv y opencv_contrib

La biblioteca OpenCV usa la versión opencv-4.3.0. La biblioteca opencv_contrib no se usa por el momento y no es necesario instalarla.

  • Instalación de OpenCL: aceleración de modelos

 Tutorial de instalación:Ubuntu16.04 Instalación de OpenCV y OpenCL

OpenCL se usa para la aceleración de GPU del modelo. Si no se usa OpenCL para la aceleración de inferencia de modelos, el modelo de inferencia de C++ puro será extremadamente lento.

  • base-utils: biblioteca C++

GitHub: https://github.com/PanJinquan/base-utils (no requiere instalación, el proyecto ya está configurado)

base_utils es una biblioteca de C++ comúnmente utilizada para el desarrollo personal, que integra algoritmos comunes como C/C++ OpenCV.

  • TNN: inferencia del modelo

GitHub: https://github.com/Tencent/TNN (No se requiere instalación, el proyecto ya está configurado)

El marco de inferencia de redes neuronales liviano y de alto rendimiento de código abierto de Tencent Youtu Lab también tiene muchas ventajas sobresalientes, como multiplataforma, alto rendimiento, compresión de modelos y adaptación de código. El marco TNN fortalece aún más el soporte y la optimización del rendimiento de los dispositivos móviles sobre la base de los marcos originales Rapidnet y ncnn, y aprovecha las características de alto rendimiento y buena escalabilidad de los principales marcos de código abierto de la industria para ampliar el soporte para X86 y NV en segundo plano. GPU. TNN del lado móvil se ha implementado en muchas aplicaciones, como QQ móvil, Weishi, PTu, etc. El TNN del lado del servidor, como marco de aceleración básico de Tencent Cloud AI, ha brindado soporte acelerado para la implementación de muchas empresas.

(3) Implementar el modelo TNN

El proyecto implementa la versión C/C++ de detección de puntos clave de la punta y la tapa del lápiz. La detección de manos (detección de manos y bolígrafos) utiliza el modelo YOLOv5.Punto clave de la punta y la tapa del lápiz detecciónUtilice el modelo HRNet, el razonamiento del modelo utiliza el marco de implementación TNN (admite el razonamiento acelerado de CPU y GPU de subprocesos múltiples); el procesamiento de imágenes utiliza la biblioteca OpenCV, la aceleración del modelo utiliza OpenCL y en tiempo real El procesamiento se puede lograr en dispositivos comunes.

Si desea implementar su propio modelo entrenado en esta demostración, puede convertir el modelo Pytorch entrenado a ONNX, luego convertirlo a un modelo TNN y luego reemplazar el modelo original con su propio modelo TNN.

(4) Configuración de CMake

Este es CMakeLists.txt, que contiene la configuración principalOpenCV+OpenCL+base-utils+TNNEstas cuatro bibliotecas están disponibles para Windows sistemas. Configúrelo y compílelo usted mismo

cmake_minimum_required(VERSION 3.5)
project(Detector)

add_compile_options(-fPIC) # fix Bug: can not be used when making a shared object
set(CMAKE_CXX_FLAGS "-Wall -std=c++11 -pthread")
#set(CMAKE_CXX_FLAGS_RELEASE "-O2 -DNDEBUG")
#set(CMAKE_CXX_FLAGS_DEBUG "-g")

if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
    # -DCMAKE_BUILD_TYPE=Debug
    # -DCMAKE_BUILD_TYPE=Release
    message(STATUS "No build type selected, default to Release")
    set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Build type (default Debug)" FORCE)
endif ()

# opencv set
find_package(OpenCV REQUIRED)
include_directories(${OpenCV_INCLUDE_DIRS} ./src/)
#MESSAGE(STATUS "OpenCV_INCLUDE_DIRS = ${OpenCV_INCLUDE_DIRS}")

# base_utils
set(BASE_ROOT 3rdparty/base-utils) # 设置base-utils所在的根目录
add_subdirectory(${BASE_ROOT}/base_utils/ base_build) # 添加子目录到build中
include_directories(${BASE_ROOT}/base_utils/include)
include_directories(${BASE_ROOT}/base_utils/src)
MESSAGE(STATUS "BASE_ROOT = ${BASE_ROOT}")


# TNN set
# Creates and names a library, sets it as either STATIC
# or SHARED, and provides the relative paths to its source code.
# You can define multiple libraries, and CMake buil ds it for you.
# Gradle automatically packages shared libraries with your APK.
# build for platform
# set(TNN_BUILD_SHARED OFF CACHE BOOL "" FORCE)
if (CMAKE_SYSTEM_NAME MATCHES "Android")
    set(TNN_OPENCL_ENABLE ON CACHE BOOL "" FORCE)
    set(TNN_ARM_ENABLE ON CACHE BOOL "" FORCE)
    set(TNN_BUILD_SHARED OFF CACHE BOOL "" FORCE)
    set(TNN_OPENMP_ENABLE ON CACHE BOOL "" FORCE)  # Multi-Thread
    #set(TNN_HUAWEI_NPU_ENABLE OFF CACHE BOOL "" FORCE)
    add_definitions(-DTNN_OPENCL_ENABLE)           # for OpenCL GPU
    add_definitions(-DTNN_ARM_ENABLE)              # for Android CPU
    add_definitions(-DDEBUG_ANDROID_ON)            # for Android Log
    add_definitions(-DPLATFORM_ANDROID)
elseif (CMAKE_SYSTEM_NAME MATCHES "Linux")
    set(TNN_OPENCL_ENABLE ON CACHE BOOL "" FORCE)
    set(TNN_CPU_ENABLE ON CACHE BOOL "" FORCE)
    set(TNN_X86_ENABLE OFF CACHE BOOL "" FORCE)
    set(TNN_QUANTIZATION_ENABLE OFF CACHE BOOL "" FORCE)
    set(TNN_OPENMP_ENABLE ON CACHE BOOL "" FORCE)  # Multi-Thread
    add_definitions(-DTNN_OPENCL_ENABLE)           # for OpenCL GPU
    add_definitions(-DDEBUG_ON)                    # for WIN/Linux Log
    add_definitions(-DDEBUG_LOG_ON)                # for WIN/Linux Log
    add_definitions(-DDEBUG_IMSHOW_OFF)            # for OpenCV show
    add_definitions(-DPLATFORM_LINUX)
elseif (CMAKE_SYSTEM_NAME MATCHES "Windows")
    set(TNN_OPENCL_ENABLE ON CACHE BOOL "" FORCE)
    set(TNN_CPU_ENABLE ON CACHE BOOL "" FORCE)
    set(TNN_X86_ENABLE ON CACHE BOOL "" FORCE)
    set(TNN_QUANTIZATION_ENABLE OFF CACHE BOOL "" FORCE)
    set(TNN_OPENMP_ENABLE ON CACHE BOOL "" FORCE)  # Multi-Thread
    add_definitions(-DTNN_OPENCL_ENABLE)           # for OpenCL GPU
    add_definitions(-DDEBUG_ON)                    # for WIN/Linux Log
    add_definitions(-DDEBUG_LOG_ON)                # for WIN/Linux Log
    add_definitions(-DDEBUG_IMSHOW_OFF)            # for OpenCV show
    add_definitions(-DPLATFORM_WINDOWS)
endif ()
set(TNN_ROOT 3rdparty/TNN)
include_directories(${TNN_ROOT}/include)
include_directories(${TNN_ROOT}/third_party/opencl/include)
add_subdirectory(${TNN_ROOT}) # 添加外部项目文件夹
set(TNN -Wl,--whole-archive TNN -Wl,--no-whole-archive)# set TNN library
MESSAGE(STATUS "TNN_ROOT = ${TNN_ROOT}")

# Detector
include_directories(src)
set(SRC_LIST
        src/Interpreter.cpp
        src/pose_detector.cpp
        src/object_detection.cpp
        src/pose_filter.cpp
        src/yolov5.cpp
        )
add_library(dlcv SHARED ${SRC_LIST})
target_link_libraries(dlcv ${OpenCV_LIBS} base_utils)
MESSAGE(STATUS "DIR_SRCS = ${SRC_LIST}")
add_executable(Detector src/main.cpp)
target_link_libraries(Detector dlcv ${TNN} -lpthread)

(5) código fuente principal

La implementación de la función principal en el programa principal proporciona el método de utilizar la detección de puntos clave de la punta y la tapa del lápiz, y admitepruebas de imágenes, vídeos y cámaras

  •     Test_image_file(); // Archivo de imagen de prueba
  •     Test_video_file(); //Prueba el archivo de vídeo
  •     Test_camera(); //Cámara de prueba
//
// Created by [email protected] on 2020/6/3.
//

#include "object_detection.h"
#include "yolov5.h"
#include "Types.h"
#include <iostream>
#include <string>
#include <vector>
#include "file_utils.h"
#include "image_utils.h"

using namespace dl;
using namespace vision;
using namespace std;

const int num_thread = 1; // 开启CPU线程数目
DeviceType device = GPU;  // 选择运行设备CPU/GPU

// 目标检测SSD或者YOLOv5
const float scoreThresh = 0.5;
const float iouThresh = 0.3;
//const char *det_model_file = (char *) "../data/tnn/ssd/rfb1.0_person_320_320_sim.opt.tnnmodel";
//const char *det_proto_file = (char *) "../data/tnn/ssd/rfb1.0_person_320_320_sim.opt.tnnproto";
//ObjectDetectionParam model_param = PERSON_MODEL;//模型参数
//ObjectDetection *detector = new ObjectDetection(det_model_file, det_proto_file, model_param, num_thread, device);

const char *det_model_file = (char *) "../data/tnn/yolov5/yolov5s05_320.sim.tnnmodel";
const char *det_proto_file = (char *) "../data/tnn/yolov5/yolov5s05_320.sim.tnnproto";
YOLOv5Param dets_model_param = YOLOv5s05_320;//模型参数
YOLOv5 *detector = new YOLOv5(det_model_file,
                              det_proto_file,
                              dets_model_param,
                              num_thread,
                              device);
// 关键点检测
const float poseThresh = 0.3;
const char *pose_model_file = (char *) "../data/tnn/pose/litehrnet18_192_192.sim.tnnmodel";
const char *pose_proto_file = (char *) "../data/tnn/pose/litehrnet18_192_192.sim.tnnproto";
PoseParam pose_model_param = HAND_PARAM;//模型参数
PoseDetector *pose = new PoseDetector(pose_model_file, pose_proto_file, pose_model_param, num_thread, device);

void test_image_file() {
    //测试图片的目录
    string image_dir = "../data/test_image";
    std::vector<string> image_list = get_files_list(image_dir);
    for (string image_path:image_list) {
        cv::Mat bgr = cv::imread(image_path);
        if (bgr.empty()) continue;
        FrameInfo resultInfo;
        // 进行目标检测
        detector->detect(bgr, &resultInfo, scoreThresh, iouThresh);
        // 进行关键点检测
        pose->detect(bgr, &resultInfo, poseThresh);
        // 可视化代码
        pose->visualizeResult(bgr, resultInfo, pose_model_param.skeleton, false, 0);
    }

    delete detector;
    detector = nullptr;
    delete pose;
    pose = nullptr;
    printf("FINISHED.\n");
}


/***
 * 测试视频文件
 * @return
 */
int test_video_file() {
    //测试视频文件
    string video_file = "../data/video/video-test.mp4";
    cv::VideoCapture cap;
    bool ret = get_video_capture(video_file, cap);
    cv::Mat frame;
    while (ret) {
        cap >> frame;
        if (frame.empty()) break;
        FrameInfo resultInfo;
        // 进行目标检测
        detector->detect(frame, &resultInfo, scoreThresh, iouThresh);
        // 进行关键点检测
        pose->detect(frame, &resultInfo, poseThresh);
        // 可视化代码
        pose->visualizeResult(frame, resultInfo, pose_model_param.skeleton, false, 5);
    }
    cap.release();

    delete detector;
    detector = nullptr;
    delete pose;
    pose = nullptr;
    printf("FINISHED.\n");
    return 0;

}


/***
 * 测试摄像头
 * @return
 */
int test_camera() {
    int camera = 0; //摄像头ID号(请修改成自己摄像头ID号)
    cv::VideoCapture cap;
    bool ret = get_video_capture(camera, cap);
    cv::Mat frame;
    while (ret) {
        cap >> frame;
        if (frame.empty()) break;
        FrameInfo resultInfo;
        // 进行目标检测
        detector->detect(frame, &resultInfo, scoreThresh, iouThresh);
        // 进行关键点检测
        pose->detect(frame, &resultInfo, poseThresh);
        // 可视化代码
        pose->visualizeResult(frame, resultInfo, pose_model_param.skeleton, false, 5);
    }
    cap.release();
    delete detector;
    detector = nullptr;
    delete pose;
    pose = nullptr;
    printf("FINISHED.\n");
    return 0;

}



int main() {
    test_image_file();   // 测试图片文件
    test_video_file();   // 测试视频文件
    test_camera();       //测试摄像头
    return 0;
}

(6) Compilación y operación del código fuente

Compilar script, o directamente: bash build.sh

#!/usr/bin/env bash
if [ ! -d "build/" ];then
  mkdir "build"
else
  echo "exist build"
fi
cd build
cmake ..
make -j4
sleep 1
./Detector
  • Si desea probar el rendimiento de la operación de la CPU, modifique src/main.cpp

Dispositivo tipo dispositivo = CPU;

  • Si desea probar el rendimiento de la operación de la GPU, modifique src/main.cpp (es necesario configurar OpenCL) 

Dispositivo tipo dispositivo = GPU;

PD: El modo de inferencia pura de CPU C ++ lleva mucho tiempo y lleva varios segundos, pero después de activar la aceleración OpenCL, el modo GPU solo toma una docena de milisegundos y el rendimiento mejora enormemente.

(7) Efecto de prueba de demostración 

 Los resultados de la versión C ++ y la versión Python son casi los mismos. La siguiente es una muestra de los resultados de detección de puntos clave de la punta y la tapa del lápiz:

​

5. Descarga del código fuente del proyecto

Dirección de descarga del código fuente del proyecto:C++ implementa un algoritmo de detección de puntas y tapas de lápiz (código fuente incluido, pero detección en tiempo real)

El conjunto completo de código fuente del proyecto incluye:

  1. El código fuente C/C++ admite la detección de manos YOLOv5 (lápiz de mano)
  2. El código fuente C/C++ proporciona una versión de alta precisión de la detección de puntos clave de punta y tapa del lápiz HRNet
  3. El código fuente C/C++ proporciona detección de puntos clave de punta y tapa de lápiz modelo liviano LiteHRNet y Mobilenet-v2
  4. El código fuente C / C ++ admite CPU y GPU. Al encender la GPU (OpenCL), se puede detectar e identificar en tiempo real (la inferencia pura de la CPU es muy lenta, la aceleración del modelo requiere la configuración de OpenCL y la inferencia de GPU tarda aproximadamente 15 ms).
  5. La demostración del código fuente C/C++ admite pruebas de imágenes, vídeos y cámaras.
  6. El proyecto está configurado con base-utils y TNN, pero OpenCV y OpenCL deben compilarse e instalarse ellos mismos.

 AndroidDetección de puntos clave de la punta y la tapa del lápizExperiencia de demostración de la APLICACIÓN (Descargar< a i= 4>):

https://download.csdn.net/download/guyuealian/88535143

    

6. Edición especial: Detección de la punta del dedo del lápiz

Debido a su extensión, este artículo solo implementa la detección de puntos clave de la punta y la tapa del lápiz; en esencia, es necesario lograrlectura con la punta del dedoo a> a>; Su método de implementación es similar a la detección del punto clave de la punta del lápiz y la tapa. Función de detección de punta del lápiz + punta del dedo, es posible que no necesitemos la detección de la tapa del lápiz, pero debemos implementar Función de lectura del punto de la punta del lápiz

La siguiente es una demostración del algoritmo de detección de punta de lápiz + punta de dedo utilizado en la implementación exitosa del producto. Su precisión de detección y rendimiento de velocidad son mejores que los de la detección de punta y tapa de lápiz.

Si necesita el algoritmo de detección de punta de lápiz + punta de dedo, puede contactarnos para realizar una consulta en la cuenta oficial

Examen físico de demostración de Android con la punta del dedo:https://download.csdn.net/download/guyuealian/88558414

Detección de punta de lápiz de dedo Demo01

Detección de punta de lápiz de dedo Demo02

Supongo que te gusta

Origin blog.csdn.net/guyuealian/article/details/134070516
Recomendado
Clasificación
Diario
Más
2024-07-25(0)
2024-07-24(0)
2024-07-23(0)
2024-07-22(0)
2024-07-21(0)
2024-07-20(0)
2024-07-19(0)
2024-07-18(0)
2024-07-17(0)
2024-07-16(0)

Code World

© 2018 codetd.com