• detect_topic

    1.接收ros图像

    2.yolo识别

    3.sort跟踪

     yolo.h

    1. #ifndef YOLO_H
    2. #define YOLO_H
    3.  
    4. #include <cuda_runtime_api.h>
    5. #include <opencv2/opencv.hpp>
    6. #include "NvInfer.h"
    7. #include "NvInferPlugin.h"
    8. #include "NvInferRuntimeCommon.h"
    9. #include "NvOnnxParser.h"
    10.  
    11. #include <math.h>
    12. #include <array>
    13. #include <fstream>
    14. #include <iostream>
    15. #include <random>
    16. #include <sstream>
    17. #include <string>
    18. #include <vector>
    19.  
    20. using nvinfer1::Dims2;
    21. using nvinfer1::Dims3;
    22. using nvinfer1::IBuilder;
    23. using nvinfer1::IBuilderConfig;
    24. using nvinfer1::ICudaEngine;
    25. using nvinfer1::IExecutionContext;
    26. using nvinfer1::IHostMemory;
    27. using nvinfer1::ILogger;
    28. using nvinfer1::INetworkDefinition;
    29. using Severity = nvinfer1::ILogger::Severity;
    30.  
    31. using cv::Mat;
    32. using std::array;
    33. using std::cout;
    34. using std::endl;
    35. using std::ifstream;
    36. using std::ios;
    37. using std::ofstream;
    38. using std::string;
    39. using std::vector;
    40.  
    41.  
    42. class Logger : public ILogger {
    43.  public:
    44.   void log(Severity severity, const char* msg) noexcept override {
    45.     if (severity != Severity::kINFO) {
    46.       std::cout << msg << std::endl;
    47.     }
    48.   }
    49. };
    50.  
    51.  
    52.  
    53. class Yolo {
    54.  public:
    55.   Yolo(char* model_path);
    56.   float letterbox(
    57.       const cv::Mat& image,
    58.       cv::Mat& out_image,
    59.       const cv::Size& new_shape,
    60.       int stride,
    61.       const cv::Scalar& color,
    62.       bool fixed_shape,
    63.       bool scale_up);
    64.   float* blobFromImage(cv::Mat& img);
    65.   void draw_objects(const cv::Mat& img, float* Boxes, int* ClassIndexs, int* BboxNum, float* Scores);
    66.   void Init(char* model_path);
    67.   void Infer(
    68.       int aWidth,
    69.       int aHeight,
    70.       int aChannel,
    71.       unsigned char* aBytes,
    72.       float* Boxes,
    73.       int* ClassIndexs,
    74.       int* BboxNum,
    75.       float* Scores);
    76.   ~Yolo();
    77.  
    78.  private:
    79.   nvinfer1::ICudaEngine* engine = nullptr;
    80.   nvinfer1::IRuntime* runtime = nullptr;
    81.   nvinfer1::IExecutionContext* context = nullptr;
    82.   cudaStream_t stream = nullptr;
    83.   void* buffs[5];
    84.   int iH, iW, in_size, out_size1, out_size2, out_size3, out_size4;
    85.   Logger gLogger;
    86. };
    87.  
    88. #endif // YOLO_H

    yolo.cpp

    1. #include "yolo.h"
    2.  
    3. float Yolo::letterbox(
    4.     const cv::Mat& image,
    5.     cv::Mat& out_image,
    6.     const cv::Size& new_shape = cv::Size(640, 640),
    7.     int stride = 32,
    8.     const cv::Scalar& color = cv::Scalar(114, 114, 114),
    9.     bool fixed_shape = false,
    10.     bool scale_up = true) {
    11.   cv::Size shape = image.size();
    12.   float r = std::min(
    13.       (float)new_shape.height / (float)shape.height, (float)new_shape.width / (float)shape.width);
    14.   if (!scale_up) {
    15.     r = std::min(r, 1.0f);
    16.   }
    17.  
    18.   int newUnpad[2]{
    19.       (int)std::round((float)shape.width * r), (int)std::round((float)shape.height * r)};
    20.  
    21.   cv::Mat tmp;
    22.   if (shape.width != newUnpad[0] || shape.height != newUnpad[1]) {
    23.     cv::resize(image, tmp, cv::Size(newUnpad[0], newUnpad[1]));
    24.   } else {
    25.     tmp = image.clone();
    26.   }
    27.  
    28.   float dw = new_shape.width - newUnpad[0];
    29.   float dh = new_shape.height - newUnpad[1];
    30.  
    31.   if (!fixed_shape) {
    32.     dw = (float)((int)dw % stride);
    33.     dh = (float)((int)dh % stride);
    34.   }
    35.  
    36.   dw /= 2.0f;
    37.   dh /= 2.0f;
    38.  
    39.   int top = int(std::round(dh - 0.1f));
    40.   int bottom = int(std::round(dh + 0.1f));
    41.   int left = int(std::round(dw - 0.1f));
    42.   int right = int(std::round(dw + 0.1f));
    43.   cv::copyMakeBorder(tmp, out_image, top, bottom, left, right, cv::BORDER_CONSTANT, color);
    44.  
    45.   return 1.0f / r;
    46. }
    47.  
    48. float* Yolo::blobFromImage(cv::Mat& img) {
    49.   float* blob = new float[img.total() * 3];
    50.   int channels = 3;
    51.   int img_h = img.rows;
    52.   int img_w = img.cols;
    53.   for (size_t c = 0; c < channels; c++) {
    54.     for (size_t h = 0; h < img_h; h++) {
    55.       for (size_t w = 0; w < img_w; w++) {
    56.         blob[c * img_w * img_h + h * img_w + w] = (float)img.at<cv::Vec3b>(h, w)[c] / 255.0;
    57.       }
    58.     }
    59.   }
    60.   return blob;
    61. }
    62.  
    63. void Yolo::draw_objects(const cv::Mat& img, float* Boxes, int* ClassIndexs, int* BboxNum, float* Scores) {
    64.   for (int j = 0; j < BboxNum[0]; j++) {
    65.     cv::Rect rect(Boxes[j * 4], Boxes[j * 4 + 1], Boxes[j * 4 + 2], Boxes[j * 4 + 3]);
    66.     cv::rectangle(img, rect, cv::Scalar(0x27, 0xC1, 0x36), 2);
    67.     cv::putText(
    68.         img,
    69.         std::to_string(ClassIndexs[j])+":"+std::to_string(Scores[j]),
    70.         cv::Point(rect.x, rect.y - 1),
    71.         cv::FONT_HERSHEY_PLAIN,
    72.         1.2,
    73.         cv::Scalar(0xFF, 0xFF, 0xFF),
    74.         2);
    75.     //cv::imwrite("result.jpg", img);
    76.   }
    77. }
    78.  
    79. Yolo::Yolo(char* model_path) {
    80.   ifstream ifile(model_path, ios::in | ios::binary);
    81.   if (!ifile) {
    82.     cout << "read serialized file failed\n";
    83.     std::abort();
    84.   }
    85.  
    86.   ifile.seekg(0, ios::end);
    87.   const int mdsize = ifile.tellg();
    88.   ifile.clear();
    89.   ifile.seekg(0, ios::beg);
    90.   vector<char> buf(mdsize);
    91.   ifile.read(&buf[0], mdsize);
    92.   ifile.close();
    93.   cout << "model size: " << mdsize << endl;
    94.  
    95.   runtime = nvinfer1::createInferRuntime(gLogger);
    96.   initLibNvInferPlugins(&gLogger, "");
    97.   engine = runtime->deserializeCudaEngine((void*)&buf[0], mdsize, nullptr);
    98.   auto in_dims = engine->getBindingDimensions(engine->getBindingIndex("images"));
    99.   iH = in_dims.d[2];
    100.   iW = in_dims.d[3];
    101.   in_size = 1;
    102.   for (int j = 0; j < in_dims.nbDims; j++) {
    103.     in_size *= in_dims.d[j];
    104.   }
    105.   auto out_dims1 = engine->getBindingDimensions(engine->getBindingIndex("num_dets"));
    106.   out_size1 = 1;
    107.   for (int j = 0; j < out_dims1.nbDims; j++) {
    108.     out_size1 *= out_dims1.d[j];
    109.   }
    110.   auto out_dims2 = engine->getBindingDimensions(engine->getBindingIndex("det_boxes"));
    111.   out_size2 = 1;
    112.   for (int j = 0; j < out_dims2.nbDims; j++) {
    113.     out_size2 *= out_dims2.d[j];
    114.   }
    115.   auto out_dims3 = engine->getBindingDimensions(engine->getBindingIndex("det_scores"));
    116.   out_size3 = 1;
    117.   for (int j = 0; j < out_dims3.nbDims; j++) {
    118.     out_size3 *= out_dims3.d[j];
    119.   }
    120.   auto out_dims4 = engine->getBindingDimensions(engine->getBindingIndex("det_classes"));
    121.   out_size4 = 1;
    122.   for (int j = 0; j < out_dims4.nbDims; j++) {
    123.     out_size4 *= out_dims4.d[j];
    124.   }
    125.   context = engine->createExecutionContext();
    126.   if (!context) {
    127.     cout << "create execution context failed\n";
    128.     std::abort();
    129.   }
    130.  
    131.   cudaError_t state;
    132.   state = cudaMalloc(&buffs[0], in_size * sizeof(float));
    133.   if (state) {
    134.     cout << "allocate memory failed\n";
    135.     std::abort();
    136.   }
    137.   state = cudaMalloc(&buffs[1], out_size1 * sizeof(int));
    138.   if (state) {
    139.     cout << "allocate memory failed\n";
    140.     std::abort();
    141.   }
    142.  
    143.   state = cudaMalloc(&buffs[2], out_size2 * sizeof(float));
    144.   if (state) {
    145.     cout << "allocate memory failed\n";
    146.     std::abort();
    147.   }
    148.  
    149.   state = cudaMalloc(&buffs[3], out_size3 * sizeof(float));
    150.   if (state) {
    151.     cout << "allocate memory failed\n";
    152.     std::abort();
    153.   }
    154.  
    155.   state = cudaMalloc(&buffs[4], out_size4 * sizeof(int));
    156.   if (state) {
    157.     cout << "allocate memory failed\n";
    158.     std::abort();
    159.   }
    160.  
    161.   state = cudaStreamCreate(&stream);
    162.   if (state) {
    163.     cout << "create stream failed\n";
    164.     std::abort();
    165.   }
    166. }
    167.  
    168. void Yolo::Infer(
    169.     int aWidth,
    170.     int aHeight,
    171.     int aChannel,
    172.     unsigned char* aBytes,
    173.     float* Boxes,
    174.     int* ClassIndexs,
    175.     int* BboxNum,
    176.     float* Scores) {
    177.   cv::Mat img(aHeight, aWidth, CV_MAKETYPE(CV_8U, aChannel), aBytes);
    178.   cv::Mat pr_img;
    179.   float scale = letterbox(img, pr_img, {iW, iH}, 32, {114, 114, 114}, true);
    180.   cv::cvtColor(pr_img, pr_img, cv::COLOR_BGR2RGB);
    181.   float* blob = blobFromImage(pr_img);
    182.  
    183.   static int* num_dets = new int[out_size1];
    184.   static float* det_boxes = new float[out_size2];
    185.   static float* det_scores = new float[out_size3];
    186.   static int* det_classes = new int[out_size4];
    187.  
    188.   cudaError_t state =
    189.       cudaMemcpyAsync(buffs[0], &blob[0], in_size * sizeof(float), cudaMemcpyHostToDevice, stream);
    190.   if (state) {
    191.     cout << "transmit to device failed\n";
    192.     std::abort();
    193.   }
    194.   context->enqueueV2(&buffs[0], stream, nullptr);
    195.   state =
    196.       cudaMemcpyAsync(num_dets, buffs[1], out_size1 * sizeof(int), cudaMemcpyDeviceToHost, stream);
    197.   if (state) {
    198.     cout << "transmit to host failed \n";
    199.     std::abort();
    200.   }
    201.   state = cudaMemcpyAsync(
    202.       det_boxes, buffs[2], out_size2 * sizeof(float), cudaMemcpyDeviceToHost, stream);
    203.   if (state) {
    204.     cout << "transmit to host failed \n";
    205.     std::abort();
    206.   }
    207.   state = cudaMemcpyAsync(
    208.       det_scores, buffs[3], out_size3 * sizeof(float), cudaMemcpyDeviceToHost, stream);
    209.   if (state) {
    210.     cout << "transmit to host failed \n";
    211.     std::abort();
    212.   }
    213.  
    214.   state = cudaMemcpyAsync(
    215.       det_classes, buffs[4], out_size4 * sizeof(int), cudaMemcpyDeviceToHost, stream);
    216.   if (state) {
    217.     cout << "transmit to host failed \n";
    218.     std::abort();
    219.   }
    220.   BboxNum[0] = num_dets[0];
    221.   int img_w = img.cols;
    222.   int img_h = img.rows;
    223.   int x_offset = (iW * scale - img_w) / 2;
    224.   int y_offset = (iH * scale - img_h) / 2;
    225.   for (size_t i = 0; i < num_dets[0]; i++) {
    226.     float x0 = (det_boxes[i * 4]) * scale - x_offset;
    227.     float y0 = (det_boxes[i * 4 + 1]) * scale - y_offset;
    228.     float x1 = (det_boxes[i * 4 + 2]) * scale - x_offset;
    229.     float y1 = (det_boxes[i * 4 + 3]) * scale - y_offset;
    230.     x0 = std::max(std::min(x0, (float)(img_w - 1)), 0.f);
    231.     y0 = std::max(std::min(y0, (float)(img_h - 1)), 0.f);
    232.     x1 = std::max(std::min(x1, (float)(img_w - 1)), 0.f);
    233.     y1 = std::max(std::min(y1, (float)(img_h - 1)), 0.f);
    234.     Boxes[i * 4] = x0;
    235.     Boxes[i * 4 + 1] = y0;
    236.     Boxes[i * 4 + 2] = x1 - x0;
    237.     Boxes[i * 4 + 3] = y1 - y0;
    238.     ClassIndexs[i] = det_classes[i];
    239.     Scores[i] = det_scores[i];
    240.   }
    241.   delete blob;
    242. }
    243.  
    244. Yolo::~Yolo() {
    245.   cudaStreamSynchronize(stream);
    246.   cudaFree(buffs[0]);
    247.   cudaFree(buffs[1]);
    248.   cudaFree(buffs[2]);
    249.   cudaFree(buffs[3]);
    250.   cudaFree(buffs[4]);
    251.   cudaStreamDestroy(stream);
    252.   context->destroy();
    253.   engine->destroy();
    254.   runtime->destroy();
    255. }
    256.

     listenerMat.cpp

    1. // 1.包含头文件；
    2. #include "rclcpp/rclcpp.hpp"
    3. #include "std_msgs/msg/string.hpp"
    4. #include <cv_bridge/cv_bridge.h>
    5. #include <sensor_msgs/msg/image.hpp>
    6. #include <opencv4/opencv2/opencv.hpp>
    7. #include "utils.h"
    8. #include "kalmanboxtracker.h"
    9. #include "sort.h"
    10. #include <algorithm>
    11. #include <vector>
    12. #include <iostream>
    13.  
    14. #include "std_msgs/msg/string.hpp"
    15.  
    16. using namespace std::chrono_literals;
    17. using namespace std::chrono_literals;
    18. using std::placeholders::_1;
    19. //using std::placeholders::_1;
    20. using std::placeholders::_2;
    21.  
    22. #include "yolo.h"
    23.  
    24.  
    25. Yolo *myyolo;
    26. sort *mot_tracker;
    27.  
    28. std::vector<cv::Vec3b> colors;
    29.  
    30. std::string msgstr = "";
    31.  
    32. cv::Mat detectResultMat = cv::Mat::zeros(1080,720,CV_8UC3);
    33.  
    34.  
    35. void filter(float* Boxes,int* ClassIndexs,int* BboxNum,float* Scores,
    36.             float conf_thres, std::vector<int> classes,float *newBoxes,
    37.                     int *newClassIndexs,int *newBboxNum,float *newScores)
    38. {
    39.     int count = 0;
    40.     for (int i =0;i<BboxNum[0];i++) {
    41.       if (Scores[i]>conf_thres){
    42.         std::vector<int>::iterator iter=std::find(classes.begin(),classes.end(),ClassIndexs[i]);
    43.         if ( iter!=classes.end())
    44.         {
    45.           //cout << "Not found" << endl;
    46.           for (int j=0;j<4;j++) {
    47.             newBoxes[count*4+j]=Boxes[i*4+j];
    48.             }
    49.  
    50.             newClassIndexs[count]=ClassIndexs[i];
    51.  
    52.             newScores[count]=Scores[i];
    53.  
    54.             count++;
    55.         }
    56.       }
    57.  
    58.     }
    59.  
    60.     newBboxNum[0]=count;
    61. }
    62.  
    63. // 3.定义节点类；
    64. class MinimalSubscriber : public rclcpp::Node
    65. {
    66.   public:
    67.     MinimalSubscriber(std::string name)
    68.     : Node(name)
    69.     {
    70.       srand(time(0));
    71.       for (size_t i = 0; i < 100; i++)
    72.         colors.push_back(cv::Vec3b(rand() % 255, rand() % 255, rand() % 255));
    73.  
    74.       mot_tracker = new sort(5, 4, 0.25);
    75.  
    76.       // 3-1.创建订阅方；
    77.       //subscription_ = this->create_subscription<sensor_msgs::msg::CompressedImage>("pubImageTopic", 10, std::bind(&MinimalSubscriber::topic_callback, this, _1));
    78.       subscription_ = this->create_subscription<sensor_msgs::msg::CompressedImage>("pubImageTopic", 10, std::bind(&MinimalSubscriber::topic_callback, this, _1));
    79.  
    80.  
    81.        // 3-1.创建发布方；
    82.       msgPublisher_ = this->create_publisher<std_msgs::msg::String>("detectResultMsgtopic", 10);
    83.       // 3-2.创建定时器；
    84.       msgTimer = this->create_wall_timer(50ms, std::bind(&MinimalSubscriber::msg_timer_callback, this));
    85.  
    86.       //mat topic
    87.       matPublisher_ = this->create_publisher<sensor_msgs::msg::CompressedImage>("detectResultMatTopic", 10);
    88.       matTimer = this->create_wall_timer(50ms, std::bind(&MinimalSubscriber::mat_timer_callback, this));
    89.     }
    90.  
    91.   private:
    92.     // 3-2.处理订阅到的消息；
    93.  
    94.     //rclcpp::Subscription<sensor_msgs::msg::CompressedImage> subscription_;
    95.     rclcpp::Subscription<sensor_msgs::msg::CompressedImage>::SharedPtr subscription_;
    96.  
    97.     //void topic_callback(const sensor_msgs::msg::CompressedImage & msg) const
    98.  
    99.     rclcpp::TimerBase::SharedPtr msgTimer;
    100.     rclcpp::Publisher<std_msgs::msg::String>::SharedPtr msgPublisher_;
    101.  
    102.     //std_msgs::msg::String detectResultMessage;// = std_msgs::msg::String();
    103.     //detectResultMessage.data  = "null";
    104.  
    105.  
    106.     rclcpp::TimerBase::SharedPtr matTimer;
    107.     rclcpp::Publisher<sensor_msgs::msg::CompressedImage>::SharedPtr matPublisher_;
    108.  
    109.     //sensor_msgs::msg::CompressedImage::SharedPtr detect_result_img_compressed_;// = cv_bridge::CvImage(std_msgs::msg::Header(), "bgr8", des1080).toCompressedImageMsg();
    110.  
    111.  
    112.  
    113.     void msg_timer_callback(){
    114.       // 3-3.组织消息并发布。
    115.       auto detectResultMessage = std_msgs::msg::String();
    116.       detectResultMessage.data = msgstr;
    117.       RCLCPP_INFO(this->get_logger(), "发布的消息：'%s'", detectResultMessage.data.c_str());
    118.       msgPublisher_ ->publish(detectResultMessage);
    119.     }
    120.  
    121.  
    122.     void mat_timer_callback(){
    123.       sensor_msgs::msg::CompressedImage::SharedPtr detect_result_img_compressed_ = cv_bridge::CvImage(std_msgs::msg::Header(), "bgr8", detectResultMat).toCompressedImageMsg();
    124.       //RCLCPP_INFO(this->get_logger(), "发布的消息：检测图片");
    125.       this->matPublisher_ ->publish(*detect_result_img_compressed_);
    126.     }
    127.  
    128.  
    129.     
    130.     void topic_callback(const sensor_msgs::msg::CompressedImage::ConstPtr  msg) const
    131.     {
    132.  
    133.     try
    134.     {
    135.       cv_bridge::CvImagePtr cv_ptr_compressed = cv_bridge::toCvCopy(msg,sensor_msgs::image_encodings::BGR8);
    136.       cv::Mat imgCallback = cv_ptr_compressed->image;
    137.       //cv::imshow("imgCallback",imgCallback);
    138.       //cv::waitKey(1);
    139.  
    140.       cv::Mat des1080;
    141.  
    142.       //cv::resize(imgCallback, des1080, cv::Size(1920, 1080), 0, 0, cv::INTER_NEAREST);
    143.  
    144.       cv::resize(imgCallback, des1080, cv::Size(1080, 720), 0, 0, cv::INTER_NEAREST);
    145.  
    146.  
    147.       //std::cout<<"cv_ptr_compressed: "<<cv_ptr_compressed->image.cols<<" h: "<<cv_ptr_compressed->image.rows<<std::endl;
    148.       //std::cout<<des1080.size()<<std::endl;
    149.  
    150.       float* Boxes = new float[400];
    151.       int* BboxNum = new int[1];
    152.       int* ClassIndexs = new int[100];
    153.       float* Scores = new float[100];
    154.  
    155.       //auto start = std::chrono::system_clock::now();
    156.       myyolo->Infer(des1080.cols, des1080.rows, des1080.channels(), des1080.data, Boxes, ClassIndexs, BboxNum,Scores);
    157.       //auto end = std::chrono::system_clock::now();
    158.  
    159.       //std::cout<<std::chrono::duration_cast<std::chrono::milliseconds>(end-start).count()<<"ms"<<std::endl;
    160.  
    161.       //myyolo->draw_objects(des1080, Boxes, ClassIndexs, BboxNum, Scores);
    162.       float newBoxes[400];
    163.       int newBboxNum[1]; 
    164.       int newClassIndexs[100]; 
    165.       float newScores[100];
    166.       float conf_thres = 0.4;
    167.       std::vector<int> classes;
    168.       //classes.push_back(1);//识别车
    169.       classes.push_back(0);//识别人
    170.  
    171.       filter(Boxes, ClassIndexs, BboxNum,Scores,conf_thres,classes,newBoxes,newClassIndexs,newBboxNum,newScores);
    172.      
    173.       std::vector<cv::Rect> detections;
    174.  
    175.       for (int i =0; i< newBboxNum[0]; i++){
    176.  
    177.            cv::Rect rect(newBoxes[i * 4], newBoxes[i * 4 + 1], newBoxes[i * 4 + 2], newBoxes[i * 4 + 3]);
    178.            detections.push_back(rect);
    179.        }
    180.  
    181.        std::vector<std::vector<float>> trackers = mot_tracker->update(detections);
    182.        //qDebug()<<trackers;
    183.        std::string sendstr = "";
    184.        if(!trackers.empty()){
    185.  
    186.             for (auto tracker : trackers)
    187.             {
    188.                 cv::rectangle(des1080, cv::Rect(tracker[0], tracker[1],
    189.                             tracker[2]- tracker[0], tracker[3]- tracker[1]),
    190.                             colors[int(tracker[4])%100], 2);
    191.                 cv::putText(des1080,std::to_string(int(tracker[4])),
    192.                 cv::Point(tracker[0], tracker[1]),
    193.                 cv::FONT_HERSHEY_PLAIN,1.5,
    194.                 colors[int(tracker[4])%100],
    195.                 2);
    196.               
    197.           std::string objnum = std::to_string(int(tracker[4]));
    198.           std::string x0 = std::to_string(int(tracker[0]));
    199.           std::string y0 = std::to_string(int(tracker[1]));
    200.  
    201.           std::string x1 = std::to_string(int(tracker[2]));
    202.           std::string y1 = std::to_string(int(tracker[3]));
    203.           sendstr = sendstr+objnum+","+x0+","+y0+","+x1+","+y1+";";
    204.           }
    205.         
    206.           //this->detectResultMessage.data  = std::to_string(84);
    207.           //msgstr = "sddh15151515";
    208.           //std::string str
    209.           msgstr = sendstr;
    210.  
    211.        }
    212.        else{
    213.           //msgstr = "null";
    214.           msgstr = sendstr;
    215.        }
    216.  
    217.  
    218.  
    219.       cv::imshow("des1080",des1080);
    220.       cv::waitKey(1);
    221.  
    222.  
    223.       detectResultMat = des1080;
    224.  
    225.       //auto end = std::chrono::system_clock::now();
    226.  
    227.       //std::cout<<std::chrono::duration_cast<std::chrono::milliseconds>(end-start).count()<<"ms"<<std::endl;
    228.  
    229.     }
    230.     catch (cv_bridge::Exception& e)
    231.     {
    232.       std::cout<<"Could not convert !!!"<<std::endl;
    233.       //cv::Mat des1080;
    234.       //detectResultMat = des1080;
    235.     }  
    236.     }
    237.     
    238. };
    239.  
    240. int main(int argc, char * argv[])
    241. {
    242.  
    243.   std::string str = "./src/detect_topic/src/yolov7-tiny-nms.trt";
    244.   char* chr = const_cast(str.c_str());
    245.   myyolo = new Yolo(chr);
    246.   // 2.初始化 ROS2 客户端；
    247.   rclcpp::init(argc, argv);
    248.   // 4.调用spin函数，并传入节点对象指针。
    249.   auto node = std::make_shared<MinimalSubscriber>("detect");
    250.   rclcpp::spin(node);
    251.   //rclcpp::spin(std::make_shared<MinimalSubscriber>());
    252.   // 5.释放资源；
    253.   rclcpp::shutdown();
    254.   return 0;
    255. }

    package.xml

    1. <?xml version="1.0"?>
    2. <?xml-model href="http://download.ros.org/schema/package_format3.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
    3. <package format="3">
    4.   <name>detect_topic</name>
    5.   <version>0.0.0</version>
    6.   <description>TODO: Package description</description>
    7.   <maintainer email="1187506013@qq.com">tuya</maintainer>
    8.   <license>TODO: License declaration</license>
    9.  
    10.   <buildtool_depend>ament_cmake</buildtool_depend>
    11.  
    12.   <depend>rclcpp</depend>
    13.   <depend>std_msgs</depend>
    14.  
    15.   <test_depend>ament_lint_auto</test_depend>
    16.   <test_depend>ament_lint_common</test_depend>
    17.  
    18.   <export>
    19.     <build_type>ament_cmake</build_type>
    20.   </export>
    21. </package>

    CMakeLists.txt

    1. cmake_minimum_required(VERSION 3.8)
    2. project(detect_topic)
    3.  
    4.  
    5. add_definitions(-std=c++14)
    6.  
    7. # Default to C++14
    8. #if(NOT CMAKE_CXX_STANDARD)
    9. set(CMAKE_CXX_STANDARD 14)
    10. #endif()
    11.  
    12.  
    13. if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
    14.   add_compile_options(-Wall -Wextra -Wpedantic)
    15. endif()
    16.  
    17. # find dependencies
    18. find_package(ament_cmake REQUIRED)
    19. find_package(rclcpp REQUIRED)
    20. find_package(std_msgs REQUIRED)
    21.  
    22. find_package(cv_bridge REQUIRED)
    23. find_package(image_transport)
    24. find_package(sensor_msgs REQUIRED)
    25.  
    26. find_package(CUDA REQUIRED)
    27.  
    28. include_directories(${CUDA_INCLUDE_DIRS})
    29.  
    30. include_directories(/usr/local/cuda/include)
    31. link_directories(/usr/local/cuda/lib64)
    32. # tensorrt
    33. include_directories(/usr/include/aarch64-linux-gnu/)
    34. link_directories(/usr/lib/aarch64-linux-gnu/)
    35.  
    36. # tensorrt
    37. #include_directories(/home/tuya/TensorRT-8.6.1.6/targets/x86_64-linux-gnu/include/)
    38. #link_directories(/home/tuya/TensorRT-8.6.1.6/targets/x86_64-linux-gnu/lib/)
    39.  
    40. set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -Wall -Ofast -Wfatal-errors -D_MWAITXINTRIN_H_INCLUDED")
    41.  
    42. add_executable(detect
    43.   src/listenerMat.cpp
    44.   src/yolo.h 
    45.   src/yolo.cpp
    46.   src/hungarian.h
    47.   src/hungarian.cpp
    48.   src/kalmanboxtracker.h
    49.   src/kalmanboxtracker.cpp
    50.   src/sort.h
    51.   src/sort.cpp
    52.   src/utils.h
    53.   src/utils.cpp
    54. )
    55.  
    56. find_package(OpenCV REQUIRED)
    57. include_directories( ${OpenCV_INCLUDE_DIRS})
    58. target_link_libraries(detect ${OpenCV_LIBS})
    59.  
    60. # ros
    61. target_link_libraries(detect
    62.   ${rclcpp_LIBRARIES} 
    63. )
    64.  
    65. target_link_libraries(detect nvinfer)
    66. target_link_libraries(detect nvinfer_plugin)
    67. target_link_libraries(detect cudart)
    68.  
    69. ament_target_dependencies(detect
    70.   rclcpp
    71.   std_msgs
    72.   sensor_msgs 
    73.   cv_bridge 
    74.   OpenCV 
    75.   image_transport
    76. )
    77.  
    78.  
    79.  
    80. # 安装可执行文件
    81. install(TARGETS detect
    82.   DESTINATION lib/${PROJECT_NAME}
    83. )
    84.  
    85. ament_package()

    SORT代码

    sort demo_涂鸦c的博客-CSDN博客

  • 相关阅读:
    自动化物流运输设备模组要选择哪种类型？
    【JAVA】：万字长篇带你了解JAVA并发编程【一】
    【Java集合类面试二十】、请介绍LinkedHashMap的底层原理
    【JavaEE】_Spring MVC项目之建立连接
    Git 行结束符:LF will be replaced by CRLF the next time Git touches it问题解决指南
    Python接口自动化搭建过程，含request请求封装！
    分布式事务使用GlobalTransactional注解insert 报错java.sql.SQLException: 调用中的无效参数,
    spring boot入门与理解MVC三层架构
    1024网络技术命令汇总(第54课)
    吴恩达2022机器学习专项课程C2W2：实验SoftMax
  • 原文地址：https://blog.csdn.net/qq_16377055/article/details/133787595