Opencv_CUDA实现推理图像前处理与后处理

Opencv_CUDA实现推理图像前处理与后处理

  • 通过trt 或者 openvino部署深度学习算法时，往往会通过opencv的Mat及算法将图像转换为固定的格式作为输入
  • openvino图像的前后处理后边将在单独的文章中写出
  • 今晚空闲搜了一些opencv_cuda的使用方法，在此总结一下
  • 前提是已经通过CMake将cuda和opencv重新编译好了C++库

1.前处理

  • 参考：【基于opencv-cuda的常见图像预处理】
 
// -------------- opencv ----------------------- # 
#include <opencv2/opencv.hpp>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
// ---------------- opencv-cuda ---------------- #
#include <opencv2/cudawarping.hpp>
#include <opencv2/cudaarithm.hpp>
#include <opencv2/cudaimgproc.hpp>
 
// ------------ cuda ------------------------- #
#include <cuda_runtime_api.h>
// ------------------- nvinfer1 ------------------ # 
#include "NvInfer.h"
 
// ------------ standard libraries  --------------- # 
#include <iostream>
#include <assert.h>
#include <string>
#include <vector>
 
// ---------------------------------------------- #
 
void preprocessImage(const std::string& image_path, float* gpu_input,
                    nvinfer1::Dims3& dims)
{
    // read image
    cv::Mat frame = cv::imread(image_path);
    if(frame.empty())
    {
        std::cerr << "failed to load image: " << image_path << "!" << std::endl;
        return;
    }
    // upload
    cv::cuda::GpuMat gpu_frame;
    gpu_frame.upload(frame);
 
    // resize
    // CHW order
    auto input_width = dims.d[2];
    auto input_height = dims.d[1];
    auto channels = dims.d[0];
    
    auto input_size = cv::Size(input_width, input_height);
    cv::cuda::GpuMat resized;
    cv::cuda::resize(gpu_frame, resized, input_size, 0, 0, cv::INTER_LINEAR);
 
    //*  ------------------------ Pytorch ToTensor and Normalize ------------------- */
    cv::cuda::GpuMat flt_image;
    resized.convertTo(flt_image, CV_32FC3, 1.f/255.f);
 
    cv::cuda::subtract(flt_image, cv::Scalar(0.485f, 0.346f, 0.406f), flt_image,
                        cv::noArray(), -1);
    
    cv::cuda::divide(flt_image, cv::Scalar(0.229f, 0.224f, 0.225f), flt_image, 1, -1);
    //* ----------------------------------------------------------------------------------- /
    // BGR To RGB
    cv::cuda::GpuMat rgb;
    cv::cuda::cvtColor(flt_image, rgb, cv::COLOR_BGR2RGB);
 
    // toTensor(copy data to input float pointer channel by channel)
    std::vector<cv::cuda::GpuMat> rgb_out;
    for(size_t i=0; i<channels; ++i)
    {
        rgb_out.emplace_back(cv::cuda::GpuMat(cv::Size(input_width, input_height), CV_32FC1, gpu_input + i * input_width * input_height));
    }
 
    cv::cuda::split(flt_image, rgb_out); // opencv HWC order -> CHW order
}
 
// calculate size of tensor
size_t getSizeByDim(const nvinfer1::Dims& dims)
{
    size_t size = 1;
    for (size_t i = 0; i < dims.nbDims; ++i)
    {
        size *= dims.d[i];
    }
    return size;
}
 
int main()
{
    std::string image_path = "./turkish_coffee.jpg";
    // CHW order
    nvinfer1::Dims3 input_dim(3, 640, 640);
 
    auto input_size = getSizeByDim(input_dim) * sizeof(float);
    // allocate gpu memory for network inference
    // 此处的buffer可以认为是TensorRT engine推理时在GPU上分配的输入显存
    std::vector<void*> buffers(1);
    cudaMalloc(&buffers[0], input_size);
 
    // preprocess
    preprocessImage(image_path, (float*)buffers[0], input_dim);
 
    // download
    cv::cuda::GpuMat gpu_output;
    std::vector<cv::cuda::GpuMat> resized;
    for (size_t i = 0; i < 3; ++i)
    {
        resized.emplace_back(cv::cuda::GpuMat(cv::Size(input_dim.d[2], input_dim.d[1]), CV_32FC1, (float*)buffers[0] + i * input_dim.d[2] * input_dim.d[1]));
    }
    cv::cuda::merge(resized, gpu_output);
 
    cv::cuda::GpuMat image_out;
    // normalize
    gpu_output.convertTo(image_out, CV_32FC3, 1.f * 255.f);
    // download
    cv::Mat dst;
    image_out.download(dst);
 
    cv::imwrite("../01_test_demo.jpg", dst);
 
    for(void* buf:buffers)
    {
        cudaFree(buf);
    }
 
    return 0;
}
  • 原图与结果图：
    在这里插入图片描述

2. 输出后处理

  • 下边通过一个trt demo展示一下后处理操作
  • 源码实现如下：
#include <iostream>
#include <fstream>
#include <NvInfer.h>
#include <memory>
#include <NvOnnxParser.h>
#include <vector>
#include <cuda_runtime_api.h>
#include <opencv2/imgcodecs.hpp>
#include <opencv2/core/cuda.hpp>
#include <opencv2/cudawarping.hpp>
#include <opencv2/core.hpp>
#include <opencv2/cudaarithm.hpp>
#include <algorithm>
#include <numeric>

// destroy TensorRT objects if something goes wrong
struct TRTDestroy
{
    template <class T>
    void operator()(T* obj) const
    {
        if (obj)
        {
            obj->destroy();
        }
    }
};

template <class T>
using TRTUniquePtr = std::unique_ptr<T, TRTDestroy>;

// calculate size of tensor
size_t getSizeByDim(const nvinfer1::Dims& dims)
{
    size_t size = 1;
    for (size_t i = 0; i < dims.nbDims; ++i)
    {
        size *= dims.d[i];
    }
    return size;
}

// get classes names
std::vector<std::string> getClassNames(const std::string& imagenet_classes)
{
    std::ifstream classes_file(imagenet_classes);
    std::vector<std::string> classes;
    if (!classes_file.good())
    {
        std::cerr << "ERROR: can't read file with classes names.\n";
        return classes;
    }
    std::string class_name;
    while (std::getline(classes_file, class_name))
    {
        classes.push_back(class_name);
    }
    return classes;
}

// preprocessing stage ------------------------------------------------------------------------------------------------
void preprocessImage(const std::string& image_path, float* gpu_input, const nvinfer1::Dims& dims)
{
    // read input image
    cv::Mat frame = cv::imread(image_path);
    if (frame.empty())
    {
        std::cerr << "Input image " << image_path << " load failed\n";
        return;
    }
    cv::cuda::GpuMat gpu_frame;
    // upload image to GPU
    gpu_frame.upload(frame);

    auto input_width = dims.d[2];
    auto input_height = dims.d[1];
    auto channels = dims.d[0];
    auto input_size = cv::Size(input_width, input_height);
    // resize
    cv::cuda::GpuMat resized;
    cv::cuda::resize(gpu_frame, resized, input_size, 0, 0, cv::INTER_NEAREST);
    // normalize
    cv::cuda::GpuMat flt_image;
    resized.convertTo(flt_image, CV_32FC3, 1.f / 255.f);
    cv::cuda::subtract(flt_image, cv::Scalar(0.485f, 0.456f, 0.406f), flt_image, cv::noArray(), -1);
    cv::cuda::divide(flt_image, cv::Scalar(0.229f, 0.224f, 0.225f), flt_image, 1, -1);
    // to tensor
    std::vector<cv::cuda::GpuMat> chw;
    for (size_t i = 0; i < channels; ++i)
    {
        chw.emplace_back(cv::cuda::GpuMat(input_size, CV_32FC1, gpu_input + i * input_width * input_height));
    }
    cv::cuda::split(flt_image, chw);
}

// post-processing stage ----------------------------------------------------------------------------------------------
void postprocessResults(float *gpu_output, const nvinfer1::Dims &dims, int batch_size)
{
    // get class names
    auto classes = getClassNames("imagenet_classes.txt");

    // copy results from GPU to CPU
    std::vector<float> cpu_output(getSizeByDim(dims) * batch_size);
    cudaMemcpy(cpu_output.data(), gpu_output, cpu_output.size() * sizeof(float), cudaMemcpyDeviceToHost);

    // calculate softmax
    std::transform(cpu_output.begin(), cpu_output.end(), cpu_output.begin(), [](float val) {return std::exp(val);});
    auto sum = std::accumulate(cpu_output.begin(), cpu_output.end(), 0.0);
    // find top classes predicted by the model
    std::vector<int> indices(getSizeByDim(dims) * batch_size);
    std::iota(indices.begin(), indices.end(), 0); // generate sequence 0, 1, 2, 3, ..., 999
    std::sort(indices.begin(), indices.end(), [&cpu_output](int i1, int i2) {return cpu_output[i1] > cpu_output[i2];});
    // print results
    int i = 0;
    while (cpu_output[indices[i]] / sum > 0.005)
    {
        if (classes.size() > indices[i])
        {
            std::cout << "class: " << classes[indices[i]] << " | ";
        }
        std::cout << "confidence: " << 100 * cpu_output[indices[i]] / sum << "% | index: " << indices[i] << "\n";
        ++i;
    }
}

// main pipeline ------------------------------------------------------------------------------------------------------
int main(int argc, char* argv[])
{
    if (argc < 3)
    {
        std::cerr << "usage: " << argv[0] << " model.onnx image.jpg\n";
        return -1;
    }
    std::string model_path(argv[1]);
    std::string image_path(argv[2]);
    int batch_size = 1;

    // initialize TensorRT engine and parse ONNX model
    TRTUniquePtr<nvinfer1::ICudaEngine> engine{nullptr};
   
    //初始化engine.........省略


    // get sizes of input and output and allocate memory required for input data and for output data
    std::vector<nvinfer1::Dims> input_dims; // we expect only one input
    std::vector<nvinfer1::Dims> output_dims; // and one output
    std::vector<void*> buffers(engine->getNbBindings()); // buffers for input and output data
    for (size_t i = 0; i < engine->getNbBindings(); ++i)
    {
        auto binding_size = getSizeByDim(engine->getBindingDimensions(i)) * batch_size * sizeof(float);
        cudaMalloc(&buffers[i], binding_size);
        if (engine->bindingIsInput(i))
        {
            input_dims.emplace_back(engine->getBindingDimensions(i));
        }
        else
        {
            output_dims.emplace_back(engine->getBindingDimensions(i));
        }
    }
    if (input_dims.empty() || output_dims.empty())
    {
        std::cerr << "Expect at least one input and one output for network\n";
        return -1;
    }

    // preprocess input data
    preprocessImage(image_path, (float *) buffers[0], input_dims[0]);
    // inference
    context->enqueue(batch_size, buffers.data(), 0, nullptr);
    // postprocess results
    postprocessResults((float *) buffers[1], output_dims[0], batch_size);

    for (void* buf : buffers)
    {
        cudaFree(buf);
    }
    return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/271351.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

数据结构学习 Leetcode198 打家劫舍

数据结构学习 Leetcode198 打家劫舍

动态结构 最长上升子序列 题目&#xff1a; 解法一&#xff1a; 思路&#xff1a; 状态&#xff1a;F[i]前i间房能偷到的最大金额。 转移方程&#xff1a; 偷和不偷取最大 如果不偷&#xff1a;F[i-1]如果偷&#xff1a;nums[i]F[i-2]如果偷就不能偷前一个&#xff0c;所…
阅读更多...
【深度学习目标检测】十一、基于深度学习的电网绝缘子缺陷识别（python，目标检测，yolov8）

【深度学习目标检测】十一、基于深度学习的电网绝缘子缺陷识别（python，目标检测，yolov8）

YOLOv8是一种物体检测算法&#xff0c;是YOLO系列算法的最新版本。 YOLO&#xff08;You Only Look Once&#xff09;是一种实时物体检测算法&#xff0c;其优势在于快速且准确的检测结果。YOLOv8在之前的版本基础上进行了一系列改进和优化&#xff0c;提高了检测速度和准确性。…
阅读更多...
牛客周赛 Round 22 解题报告 | 珂学家 | 思维构造 + 最小生成树

牛客周赛 Round 22 解题报告 | 珂学家 | 思维构造 + 最小生成树

前言 整体评价 C题这个构造题挺好的&#xff0c;赛中把-1写成No, 直接整不会了&#xff0c;T_T. D题是一道很裸的最小生成树题&#xff0c;只需要一个小小的逆向思维&#xff0c;把删除操作转换为构建过程。 欢迎关注 珂朵莉 牛客周赛专栏 珂朵莉 牛客小白月赛专栏 A. 小红…
阅读更多...
HTTP content-type内容类型的常见格式

HTTP content-type内容类型的常见格式

本专栏是汇集了一些HTML常常被遗忘的知识&#xff0c;这里算是温故而知新&#xff0c;往往这些零碎的知识点&#xff0c;在你开发中能起到炸惊效果。我们每个人都没有过目不忘&#xff0c;过久不忘的本事&#xff0c;就让这一点点知识慢慢渗透你的脑海。 本专栏的风格是力求简洁…
阅读更多...
概率论中的 50 个具有挑战性的问题 [第 6 部分]：Chuck-a-Luck

概率论中的 50 个具有挑战性的问题 [第 6 部分]：Chuck-a-Luck

一、说明 我最近对与概率有关的问题产生了兴趣。我偶然读到了弗雷德里克莫斯特勒&#xff08;Frederick Mosteller&#xff09;的《概率论中的五十个具有挑战性的问题与解决方案》&#xff09;一书。我认为创建一个系列来讨论这些可能作为面试问题出现的迷人问题会很有趣。每篇…
阅读更多...
OAuth2.0 四种授权方式讲解

OAuth2.0 四种授权方式讲解

一、OAuth2.0 的理解 OAuth2是一个开放的授权标准&#xff0c;允许第三方应用程序以安全可控的方式访问受保护的资源&#xff0c;而无需用户将用户名和密码信息与第三方应用程序共享。OAuth2被广泛应用于现代Web和移动应用程序开发中&#xff0c;可以简化应用程序与资源服务器之…
阅读更多...
顺序表的基本操作（必学）

顺序表的基本操作（必学）

目录 线性表&#xff1a; 顺序表&#xff1a; 概念和结构&#xff1a; 动态顺序表常用操作实现&#xff1a; 头文件&#xff08;数组顺序表的声明&#xff09;&#xff1a; 各种基本操作总的声明&#xff1a; 顺序表的初始化&#xff1a; 顺序表的销毁 顺序表的打印 …
阅读更多...
录屏软件哪个好用？全方位测评告诉你

录屏软件哪个好用？全方位测评告诉你

随着数字技术的不断发展&#xff0c;录制屏幕的需求也越来越大。无论是制作教程、记录游戏过程&#xff0c;还是保存会议内容&#xff0c;一款好用的录屏软件都能让用户事半功倍。可是录屏软件哪个好用呢&#xff1f;在本文中&#xff0c;我们将介绍三款流行的录屏软件。通过详…
阅读更多...
std::string在 Windows MSVC和Linux Gcc 中capacity容量扩容策略的分析和对比

std::string在 Windows MSVC和Linux Gcc 中capacity容量扩容策略的分析和对比

1、capacity()作用 在std::string中&#xff0c;capacity()为当前string占用内存字符的长度&#xff0c;表示当前string的容量&#xff0c;可以理解为一个预分配制度&#xff0c;如果当前的string不断进行扩展操作&#xff0c;则不需要每次都进行内存上的分配&#xff0c;提高程…
阅读更多...
iconify图标集离线使用方案简介

iconify图标集离线使用方案简介

1.需求描述 前端项目&#xff0c;技术栈使用Vue3Element Plus&#xff0c;参考了ruoyi-vue-pro项目与vue-element-plus-admin项目&#xff0c;封装了一个Icon组件&#xff0c;图标使用的是iconify,项目部署在内网环境&#xff0c;不能连接互联网&#xff0c;需要部署一套iconi…
阅读更多...
MAC鼠标中键的使用

MAC鼠标中键的使用

MAC鼠标没有鼠标中键&#xff0c;于是在一些场景中用起来非常麻烦&#xff0c;这里介绍几种键盘快捷键鼠标左键实现中键功能的例子&#xff1a; 1&#xff09;在sublime text 或者pycharm等一些文本编辑器或IDE中实现中键修改一列数据中特定位置的值 FNOPT左键另外还有C4D&…
阅读更多...
生存分析序章1——解析生存分析：探寻时间与事件的奥秘

生存分析序章1——解析生存分析：探寻时间与事件的奥秘

写在开头 生存分析&#xff0c;作为统计学和生物学交汇的领域&#xff0c;旨在探究时间与事件之间的奥秘。这一领域的深入研究不仅在医学和生物学领域有着广泛的应用&#xff0c;同时在数据分析和数据挖掘中也发挥着关键作用。 1 基本概念 1.1 什么是生存分析 生存分析&…
阅读更多...
STM32独立看门狗和窗口看门狗的区别

STM32独立看门狗和窗口看门狗的区别

独立看门狗&#xff1a; 本质上是一个定时器&#xff0c;这个定时器有一个输出端&#xff0c;可以输出复位信号。 该定时器是一个 12 位的递减计数器&#xff0c;当计数器的值减到 0 的时候&#xff0c;就会产生一个复位信号。如果在计数没减到 0 之前&#xff0c;重置计数器的…
阅读更多...
如何使用 NestJS 集成 Passort 和 JWT Token 实现 HTTP 接口的权限管理

如何使用 NestJS 集成 Passort 和 JWT Token 实现 HTTP 接口的权限管理

&#x1f4a1; 如果你不希望其他人可以随意进出你的房子&#xff0c;那么你需要给你的房子上个锁。 前言 开发一个接口很容易&#xff0c;开发一个具有安全性的接口却不容易。成熟的后端服务项目最注重的一点就是如何保护系统的数据安全&#xff0c;不能让用户无脑的访问操作所…
阅读更多...
大数据Doris（四十一）：物化视图简单介绍

大数据Doris（四十一）：物化视图简单介绍

文章目录 物化视图简单介绍 一、适用场景
阅读更多...
利用html2Canvas将表格下载为html

利用html2Canvas将表格下载为html

给到我的需求是点击按钮时请求后端接口&#xff0c;根据后端返回的数据&#xff0c;生成表格,并将表格的内容直接下载为html,如下图。 平常做的下载都是后端返回二进制流&#xff0c;这次前端做下载那就必须把页面先画出来&#xff0c;因为下载下来的表格在页面上是不显示的&a…
阅读更多...
Keepalived 高可用详解

Keepalived 高可用详解

Keepalived 详解 1、Keepalived介绍 ​ Keepalived是一个基于VRRP协议来实现LVS服务高可用方案&#xff0c;可以利用其来避免单点故障。一个LVS服务会使用2台服务器运行Keepalived&#xff0c;一台为主服务器MASTER&#xff0c;另一台为备份服务器BACKUP&#xff0c;但是对外表…
阅读更多...
12月25日作业

12月25日作业

串口发送控制命令&#xff0c;实现一些外设LED 风扇 uart4.c #include "uart4.h"void uart4_config() {//1.使能GPIOB\GPIOG\UART4外设时钟RCC->MP_AHB4ENSETR | (0x1 << 1);RCC->MP_AHB4ENSETR | (0x1 << 6);RCC->MP_APB1ENSETR | (0x1 <…
阅读更多...
深入剖析LinkedList：揭秘底层原理

深入剖析LinkedList：揭秘底层原理

文章目录 一、 概述LinkedList1.1 LinkedList简介1.2 LinkedList的优点和缺点 二、 LinkedList数据结构分析2.1 Node节点结构体解析2.2 LinkedList实现了双向链表的原因2.3 LinkedList如何实现了链表的基本操作&#xff08;增删改查&#xff09;2.4 LinkedList的遍历方式 三、 …
阅读更多...
静态HTTP的未来：探讨新技术趋势

静态HTTP的未来：探讨新技术趋势

在Web的世界里&#xff0c;静态HTTP一直是个不可或缺的角色。它就像一个尽职尽责的邮递员&#xff0c;确保数据安全、准确地送达目的地。但随着时代的发展&#xff0c;邮递员也需要跟上潮流&#xff0c;不断学习和进步。那么&#xff0c;静态HTTP的未来会是怎样的呢&#xff1f…
阅读更多...
最新文章

Copyright @ 2022~2023