update yolox_cpp interface

Author: Ar-Ray-code

yolox_ros_cpp/README.md

@@ -195,8 +195,7 @@ ros2 launch yolox_ros_cpp yolox_tflite.launch.py
   - See [here](https://github.com/fateshelled/YOLOX-ROS/blob/dev_cpp/yolox_ros_cpp/yolox_ros_cpp/labels/coco_names.txt) for label format.
 - `num_classes`: 80
 - `model_version`: 0.1.1rc0
-- `openvino/device`: CPU
-- `conf`: 0.3
+- `openvino/device`: AUTO
 - `nms`: 0.45
 - `imshow_isshow`: true
 - `src_image_topic_name`: /image_raw

yolox_ros_cpp/yolox_cpp/src/yolox_openvino.cpp

@@ -17,6 +17,12 @@ namespace yolox_cpp{
         const auto network = ie.read_model(path_to_model);
 
         //  Step 3. Loading a model to the device
+        std::vector<std::string> available_devices = ie.get_available_devices();
+        std::cout << "======= AVAILABLE DEVICES FOR OPENVINO =======" << std::endl;
+        for (auto device : available_devices) {
+            std::cout << "- " << device << std::endl;
+        }
+        std::cout << "==============================================" << std::endl;
         std::cout << "Loading a model to the device: " << device_name_ << std::endl;
         auto compiled_model = ie.compile_model(network, device_name);
 

yolox_ros_cpp/yolox_ros_cpp/include/yolox_ros_cpp/yolox_ros_cpp.hpp

@@ -3,11 +3,13 @@
 #include <cmath>
 #include <chrono>
 
+#include <cv_bridge/cv_bridge.h>
 #include <image_transport/image_transport.hpp>
-#include <cv_bridge/cv_bridge.hpp>
 #include <rclcpp/rclcpp.hpp>
 #include <rclcpp_components/register_node_macro.hpp>
-
+#include <sensor_msgs/msg/image.hpp>
+#include <std_msgs/msg/header.hpp>
+#include <vision_msgs/msg/detection2_d_array.hpp>
 
 #include "bboxes_ex_msgs/msg/bounding_box.hpp"
 #include "bboxes_ex_msgs/msg/bounding_boxes.hpp"
@@ -17,28 +19,29 @@
 #include "yolox_param/yolox_param.hpp"
 
 namespace yolox_ros_cpp{
-
     class YoloXNode : public rclcpp::Node
     {
     public:
-        YoloXNode(const rclcpp::NodeOptions&);
+        YoloXNode(const rclcpp::NodeOptions &);
+    private:
+        void onInit();
+        void colorImageCallback(const sensor_msgs::msg::Image::ConstSharedPtr &);
+
+        static bboxes_ex_msgs::msg::BoundingBoxes objects_to_bboxes(const cv::Mat &, const std::vector<yolox_cpp::Object> &, const std_msgs::msg::Header &);
+        static vision_msgs::msg::Detection2DArray objects_to_detection2d(const std::vector<yolox_cpp::Object> &, const std_msgs::msg::Header &);
 
     protected:
         std::shared_ptr<yolox_parameters::ParamListener> param_listener_;
         yolox_parameters::Params params_;
     private:
-        void onInit();
-        rclcpp::TimerBase::SharedPtr init_timer_;
-
         std::unique_ptr<yolox_cpp::AbcYoloX> yolox_;
         std::vector<std::string> class_names_;
 
+        rclcpp::TimerBase::SharedPtr init_timer_;
         image_transport::Subscriber sub_image_;
-        void colorImageCallback(const sensor_msgs::msg::Image::ConstSharedPtr&);
 
         rclcpp::Publisher<bboxes_ex_msgs::msg::BoundingBoxes>::SharedPtr pub_bboxes_;
+        rclcpp::Publisher<vision_msgs::msg::Detection2DArray>::SharedPtr pub_detection2d_;
         image_transport::Publisher pub_image_;
-
-        bboxes_ex_msgs::msg::BoundingBoxes objects_to_bboxes(const cv::Mat&, const std::vector<yolox_cpp::Object>&, const std_msgs::msg::Header&);
     };
 }

yolox_ros_cpp/yolox_ros_cpp/package.xml

@@ -18,9 +18,12 @@
   <depend>std_msgs</depend>
   <depend>sensor_msgs</depend>
   <depend>bboxes_ex_msgs</depend>
+  <depend>vision_msgs</depend>
   <depend>yolox_cpp</depend>
   <depend>yolox_param</depend>
 
+  <exec_depend>usb_cam</exec_depend>
+
   <test_depend>ament_lint_auto</test_depend>
   <test_depend>ament_lint_common</test_depend>
 

yolox_ros_cpp/yolox_ros_cpp/src/yolox_ros_cpp.cpp

@@ -95,10 +95,20 @@ namespace yolox_ros_cpp
             this, this->params_.src_image_topic_name,
             std::bind(&YoloXNode::colorImageCallback, this, std::placeholders::_1),
             "raw");
-        this->pub_bboxes_ = this->create_publisher<bboxes_ex_msgs::msg::BoundingBoxes>(
-            this->params_.publish_boundingbox_topic_name,
-            10);
-        this->pub_image_ = image_transport::create_publisher(this, this->params_.publish_image_topic_name);
+
+        if (this->params_.use_bbox_ex_msgs) {
+            this->pub_bboxes_ = this->create_publisher<bboxes_ex_msgs::msg::BoundingBoxes>(
+                this->params_.publish_boundingbox_topic_name,
+                10);
+        } else {
+            this->pub_detection2d_ = this->create_publisher<vision_msgs::msg::Detection2DArray>(
+                this->params_.publish_boundingbox_topic_name,
+                10);
+        }
+
+        if (this->params_.publish_resized_image) {
+            this->pub_image_ = image_transport::create_publisher(this, this->params_.publish_image_topic_name);
+        }
     }
 
     void YoloXNode::colorImageCallback(const sensor_msgs::msg::Image::ConstSharedPtr &ptr)
@@ -108,10 +118,10 @@ namespace yolox_ros_cpp
 
         auto now = std::chrono::system_clock::now();
         auto objects = this->yolox_->inference(frame);
-
         auto end = std::chrono::system_clock::now();
+
         auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - now);
-        RCLCPP_INFO(this->get_logger(), "Inference: %f FPS", 1000.0f / elapsed.count());
+        RCLCPP_INFO(this->get_logger(), "Inference time: %5ld ms", elapsed.count());
 
         yolox_cpp::utils::draw_objects(frame, objects, this->class_names_);
         if (this->params_.imshow_isshow)
@@ -124,12 +134,32 @@ namespace yolox_ros_cpp
             }
         }
 
-        auto boxes = objects_to_bboxes(frame, objects, img->header);
-        this->pub_bboxes_->publish(boxes);
+        if (this->params_.use_bbox_ex_msgs)
+        {
+            if (this->pub_bboxes_ == nullptr)
+            {
+                RCLCPP_ERROR(this->get_logger(), "pub_bboxes_ is nullptr");
+                return;
+            }
+            auto boxes = objects_to_bboxes(frame, objects, img->header);
+            this->pub_bboxes_->publish(boxes);
+        }
+        else
+        {
+            if (this->pub_detection2d_ == nullptr)
+            {
+                RCLCPP_ERROR(this->get_logger(), "pub_detection2d_ is nullptr");
+                return;
+            }
+            vision_msgs::msg::Detection2DArray detections = objects_to_detection2d(objects, img->header);
+            this->pub_detection2d_->publish(detections);
+        }
 
-        sensor_msgs::msg::Image::SharedPtr pub_img;
-        pub_img = cv_bridge::CvImage(img->header, "bgr8", frame).toImageMsg();
-        this->pub_image_.publish(pub_img);
+        if (this->params_.publish_resized_image) {
+            sensor_msgs::msg::Image::SharedPtr pub_img =
+                cv_bridge::CvImage(img->header, "bgr8", frame).toImageMsg();
+            this->pub_image_.publish(pub_img);
+        }
     }
 
     bboxes_ex_msgs::msg::BoundingBoxes YoloXNode::objects_to_bboxes(
@@ -140,8 +170,8 @@ namespace yolox_ros_cpp
         for (const auto &obj : objects)
         {
             bboxes_ex_msgs::msg::BoundingBox box;
-            box.probability = obj.prob;
-            box.class_id = this->class_names_[obj.label];
+            box.probability = obj.prob;;
+            box.class_id = std::to_string(obj.label);
             box.xmin = obj.rect.x;
             box.ymin = obj.rect.y;
             box.xmax = (obj.rect.x + obj.rect.width);
@@ -152,6 +182,26 @@ namespace yolox_ros_cpp
         }
         return boxes;
     }
+
+    vision_msgs::msg::Detection2DArray YoloXNode::objects_to_detection2d(const std::vector<yolox_cpp::Object> &objects, const std_msgs::msg::Header &header)
+    {
+        vision_msgs::msg::Detection2DArray detection2d;
+        detection2d.header = header;
+        for (const auto &obj : objects)
+        {
+            vision_msgs::msg::Detection2D det;
+            det.bbox.center.position.x = obj.rect.x + obj.rect.width / 2;
+            det.bbox.center.position.y = obj.rect.y + obj.rect.height / 2;
+            det.bbox.size_x = obj.rect.width;
+            det.bbox.size_y = obj.rect.height;
+
+            det.results.resize(1);
+            det.results[0].hypothesis.class_id = std::to_string(obj.label);
+            det.results[0].hypothesis.score = obj.prob;
+            detection2d.detections.emplace_back(det);
+        }
+        return detection2d;
+    }
 }
 
 RCLCPP_COMPONENTS_REGISTER_NODE(yolox_ros_cpp::YoloXNode)