fixed msg naming

Author: brianzheng206

deep_msgs/CMakeLists.txt

@@ -27,7 +27,7 @@ find_package(rosidl_default_generators REQUIRED)
 
 rosidl_generate_interfaces(${PROJECT_NAME}
   "msg/MultiImage.msg"
-  "msg/MultiImageRaw.msg"
+  "msg/MultiImageCompressed.msg"
   DEPENDENCIES std_msgs sensor_msgs
 )
 

deep_msgs/msg/MultiImage.msg

@@ -1,5 +1,3 @@
 # MultiImage.msg
-# A message that carries multiple compressed images together
-
 std_msgs/Header header
-sensor_msgs/CompressedImage[] images
+sensor_msgs/Image[] images

deep_msgs/msg/MultiImageCompressed.msg

@@ -0,0 +1,5 @@
+# MultiImageCompressed.msg
+# A message that carries multiple compressed images together
+
+std_msgs/Header header
+sensor_msgs/CompressedImage[] images

deep_msgs/msg/MultiImageRaw.msg

@@ -7,7 +7,7 @@ A deep learning object detection node for ROS 2. Simply provide any ONNX-compati
 The `deep_object_detection` package provides:
 - Model-agnostic object detection using ONNX models
 - Automatic output format detection and adaptation
-- Multi-camera support via MultiImage messages (immediate batch processing)
+- Multi-camera support via MultiImage/MultiImageCompressed messages (immediate batch processing)
 - Configurable preprocessing and postprocessing pipelines
 - Plugin-based backend architecture (CPU, CUDA, TensorRT)
 - Full ROS 2 lifecycle node support
@@ -17,7 +17,7 @@ The `deep_object_detection` package provides:
 │                                      ROS 2 Topics                                  │
 │                                                                                    │
 │  ┌──────────────────────────────────┐       ┌──────────────────────────────┐       │
-│  │ MultiImage Topic                 │       │ Detection2DArray Topic       │       │
+│  │ MultiImage/MultiImageCompressed   │       │ Detection2DArray Topic       │       │
 │  │ (synchronized multi-camera)       │       │ (one per image in batch)     │       │
 │  │ • KeepLast(1) QoS                │       └──────────────────────────────┘       │
 │  │ • Immediate processing           │       ┌──────────────────────────────┐       │
@@ -33,10 +33,10 @@ The `deep_object_detection` package provides:
 │  ┌──────────────────────────────────────────────────────────────────────────────┐  │
 │  │                         Processing Pipeline (Per MultiImage Message)         │  │
 │  │                                                                              │  │
-│  │  MultiImage Message                                                          │  │
+│  │  MultiImage/MultiImageCompressed Message                                   │  │
 │  │  ┌──────────────────────────────────────────────────────────────────────┐  │  │
 │  │  │ 1. Decode Images (sequential)                                         │  │  │
-│  │  │    • Extract all CompressedImage from MultiImage                      │  │  │
+│  │  │    • Extract all images from MultiImage/MultiImageCompressed         │  │  │
 │  │  │    • Decode each to cv::Mat                                           │  │  │
 │  │  └────────────────────┬───────────────────────────────────────────────────┘  │  │
 │  │                       │                                                      │  │
@@ -117,14 +117,12 @@ The `deep_object_detection` package provides:
 │  └──────────────────────────┘        └──────────────────────────────────────────┘  │
 └────────────────────────────────────────────────────────────────────────────────────┘
 
-Note: Each MultiImage message is processed immediately. All images within a MultiImage
-message are processed as a single batch through inference. No queuing or batching of
-multiple MultiImage messages occurs.
+Note: Each MultiImage/MultiImageCompressed message is processed immediately. All images within a message are processed as a single batch through inference. No queuing or batching of multiple messages occurs.
 ```
 
 ### Nodes
 
-- **`deep_object_detection_node`**: A lifecycle node that subscribes to MultiImage messages (synchronized multi-camera input), runs object detection inference, and publishes detection results.
+- **`deep_object_detection_node`**: A lifecycle node that subscribes to MultiImage/MultiImageCompressed messages (synchronized multi-camera input), runs object detection inference, and publishes detection results.
 
 ### Configuration
 
@@ -198,12 +196,12 @@ The object detection node requires the `camera_sync` node for synchronized multi
      input_topic:=/multi_camera_sync/multi_image_compressed
    ```
 
-   Configure the detection node to subscribe to the MultiImage topic either via:
+   Configure the detection node to subscribe to the MultiImage/MultiImageCompressed topic either via:
    - **Remapping** (recommended): `input_topic:=/multi_camera_sync/multi_image_compressed` in launch command
    - **Parameter**: Set `input_topic: "/multi_camera_sync/multi_image_compressed"` in config file
 
-   The node processes all images in each MultiImage message as a batch. The batch size
-   is determined by the number of images in the MultiImage message (typically equal to
+   The node processes all images in each MultiImage/MultiImageCompressed message as a batch. The batch size
+   is determined by the number of images in the message (typically equal to
    the number of synchronized cameras).
 
 ### Zero-Copy Component Container (High Performance)
@@ -308,7 +306,7 @@ The node automatically detects and adapts to various ONNX model output formats:
 - `[batch, channels, anchors]` - anchor-based models
 - Any other layout - automatically detected and handled
 
-**Input:** The node expects MultiImage messages (deep_msgs/MultiImage) containing synchronized compressed images from multiple cameras.
+**Input:** The node expects MultiImageCompressed messages (deep_msgs/MultiImageCompressed) containing synchronized compressed images, or MultiImage messages (deep_msgs/MultiImage) containing synchronized uncompressed images from multiple cameras.
 
 **Output:** Detection2DArray messages containing bounding boxes, scores, and class IDs for each image in the batch.
 
@@ -325,7 +323,7 @@ The node automatically detects and adapts to various ONNX model output formats:
 
 ### Required Parameters
 - **`model_path`** (string): Absolute path to ONNX model file (e.g., `/workspaces/deep_ros/yolov8m.onnx`).
-- **`input_topic`** (string): MultiImage topic name to subscribe to.
+- **`input_topic`** (string): MultiImage/MultiImageCompressed topic name to subscribe to.
 
 ### Key Parameters
 - **`class_names_path`** (string, optional): Absolute path to text file with class names, one per line (e.g., `/workspaces/deep_ros/deep_object_detection/config/coco_classes.txt`). If not provided, class IDs will be used in output messages.
@@ -349,9 +347,9 @@ See `config/generic_model_params.yaml` for a complete parameter reference.
 Topic names can be configured either via parameters in the config file or via remappings in the launch file. Remappings take precedence over parameter values.
 
 ### Input Topics
-- **`input_topic`**: MultiImage messages (deep_msgs/MultiImage) containing synchronized compressed images from multiple cameras.
+- **`input_topic`**: MultiImageCompressed messages (deep_msgs/MultiImageCompressed) containing synchronized compressed images, or MultiImage messages (deep_msgs/MultiImage) containing synchronized uncompressed images from multiple cameras.
 
-**Note:** The node only supports MultiImage messages. Individual camera topics are not supported.
+**Note:** The node only supports MultiImage/MultiImageCompressed messages. Individual camera topics are not supported.
 
 **Configuration:**
 - Via parameter: Set `input_topic` in the config file
@@ -382,8 +380,8 @@ Topic names can be configured either via parameters in the config file or via re
 
 ## Limitations
 
-1. **MultiImage input only**: The node only supports MultiImage messages. Individual camera topics are not supported.
-2. **MultiImage input format**: The node processes MultiImage messages immediately upon receipt. All images within a MultiImage message are processed as a single batch. No queuing or accumulation of multiple MultiImage messages occurs.
+1. **MultiImage/MultiImageCompressed input only**: The node only supports MultiImage/MultiImageCompressed messages. Individual camera topics are not supported.
+2. **Message processing**: The node processes MultiImage/MultiImageCompressed messages immediately upon receipt. All images within a message are processed as a single batch. No queuing or accumulation of multiple messages occurs.
 3. **No dynamic reconfiguration**: Parameters cannot be changed at runtime. Node must be reconfigured to change parameters.
 
 ## Testing

deep_object_detection/README.md

@@ -17,7 +17,7 @@
  * @brief ROS 2 lifecycle node for object detection using ONNX models
  *
  * This header defines the main DeepObjectDetectionNode class which:
- * - Subscribes to MultiImage messages (synchronized multi-camera input)
+ * - Subscribes to MultiImage/MultiImageCompressed messages (synchronized multi-camera input)
  * - Processes MultiImage messages directly without additional batching
  * - Runs preprocessing, inference, and postprocessing
  * - Publishes Detection2DArray messages with bounding boxes and scores
@@ -33,7 +33,7 @@
 #include <deep_core/deep_node_base.hpp>
 #include <deep_core/types/tensor.hpp>
 #include <deep_msgs/msg/multi_image.hpp>
-#include <deep_msgs/msg/multi_image_raw.hpp>
+#include <deep_msgs/msg/multi_image_compressed.hpp>
 #include <opencv2/core/mat.hpp>
 #include <rclcpp/node_options.hpp>
 #include <rclcpp/rclcpp.hpp>
@@ -53,9 +53,9 @@ namespace deep_object_detection
 /**
  * @brief ROS2 lifecycle node for object detection using ONNX models
  *
- * This node performs object detection on synchronized multi-camera streams via MultiImage messages.
+ * This node performs object detection on synchronized multi-camera streams via MultiImage/MultiImageCompressed messages.
  * It supports:
- * - MultiImage input: synchronized compressed images from multiple cameras
+ * - MultiImage/MultiImageCompressed input: synchronized images from multiple cameras
  * - Direct processing: processes MultiImage messages immediately without queuing
  * - Multiple backends: CPU, CUDA, or TensorRT execution providers
  * - Configurable preprocessing: resizing, normalization, color format conversion
@@ -145,20 +145,20 @@ class DeepObjectDetectionNode : public deep_ros::DeepNodeBase
   void setupSubscription();
 
   /**
-   * @brief Callback for MultiImage messages (compressed)
-   * @param msg Shared pointer to MultiImage message containing synchronized compressed images
+   * @brief Callback for MultiImageCompressed messages (compressed)
+   * @param msg Shared pointer to MultiImageCompressed message containing synchronized compressed images
    *
    * Converts compressed images to cv::Mat and processes them.
    */
-  void onMultiImage(const deep_msgs::msg::MultiImage::ConstSharedPtr & msg);
+  void onMultiImage(const deep_msgs::msg::MultiImageCompressed::ConstSharedPtr & msg);
 
   /**
-   * @brief Callback for MultiImageRaw messages (uncompressed)
-   * @param msg Shared pointer to MultiImageRaw message containing synchronized uncompressed images
+   * @brief Callback for MultiImage messages (uncompressed)
+   * @param msg Shared pointer to MultiImage message containing synchronized uncompressed images
    *
    * Converts uncompressed images to cv::Mat and processes them.
    */
-  void onMultiImageRaw(const deep_msgs::msg::MultiImageRaw::ConstSharedPtr & msg);
+  void onMultiImageRaw(const deep_msgs::msg::MultiImage::ConstSharedPtr & msg);
 
   /**
    * @brief Process images through the inference pipeline
@@ -232,10 +232,10 @@ class DeepObjectDetectionNode : public deep_ros::DeepNodeBase
   /// Class names loaded from file
   std::vector<std::string> class_names_;
 
-  /// Subscription to MultiImage topic (synchronized multi-camera compressed input)
-  rclcpp::Subscription<deep_msgs::msg::MultiImage>::SharedPtr multi_image_sub_;
-  /// Subscription to MultiImageRaw topic (synchronized multi-camera uncompressed input)
-  rclcpp::Subscription<deep_msgs::msg::MultiImageRaw>::SharedPtr multi_image_raw_sub_;
+  /// Subscription to MultiImageCompressed topic (synchronized multi-camera compressed input)
+  rclcpp::Subscription<deep_msgs::msg::MultiImageCompressed>::SharedPtr multi_image_sub_;
+  /// Subscription to MultiImage topic (synchronized multi-camera uncompressed input)
+  rclcpp::Subscription<deep_msgs::msg::MultiImage>::SharedPtr multi_image_raw_sub_;
   /// Input topic name (can be set via parameter or remapping)
   std::string input_topic_;
   /// Input topic name for uncompressed images (can be set via remapping)

deep_object_detection/include/deep_object_detection/deep_object_detection_node.hpp

@@ -32,7 +32,7 @@
 #include <deep_core/deep_node_base.hpp>
 #include <deep_core/types/tensor.hpp>
 #include <deep_msgs/msg/multi_image.hpp>
-#include <deep_msgs/msg/multi_image_raw.hpp>
+#include <deep_msgs/msg/multi_image_compressed.hpp>
 #include <lifecycle_msgs/msg/state.hpp>
 #include <opencv2/imgcodecs.hpp>
 #include <rclcpp/rclcpp.hpp>
@@ -389,33 +389,33 @@ void DeepObjectDetectionNode::setupSubscription()
   options.callback_group = callback_group_;
 
   if (use_compressed_images_) {
-    // Subscribe to compressed MultiImage
-    multi_image_sub_ = this->create_subscription<deep_msgs::msg::MultiImage>(
+    // Subscribe to compressed MultiImageCompressed
+    multi_image_sub_ = this->create_subscription<deep_msgs::msg::MultiImageCompressed>(
       input_topic_,
       qos_profile,
-      [this](const deep_msgs::msg::MultiImage::ConstSharedPtr msg) {
+      [this](const deep_msgs::msg::MultiImageCompressed::ConstSharedPtr msg) {
         try {
           this->onMultiImage(msg);
         } catch (const std::exception & e) {
           RCLCPP_ERROR(this->get_logger(), "Exception in onMultiImage callback: %s", e.what());
         }
       },
       options);
-    RCLCPP_INFO(this->get_logger(), "Subscribed to MultiImage (compressed) topic: %s", input_topic_.c_str());
+    RCLCPP_INFO(this->get_logger(), "Subscribed to MultiImageCompressed (compressed) topic: %s", input_topic_.c_str());
   } else {
-    // Subscribe to uncompressed MultiImageRaw
-    multi_image_raw_sub_ = this->create_subscription<deep_msgs::msg::MultiImageRaw>(
+    // Subscribe to uncompressed MultiImage
+    multi_image_raw_sub_ = this->create_subscription<deep_msgs::msg::MultiImage>(
       input_topic_raw_,
       qos_profile,
-      [this](const deep_msgs::msg::MultiImageRaw::ConstSharedPtr msg) {
+      [this](const deep_msgs::msg::MultiImage::ConstSharedPtr msg) {
         try {
           this->onMultiImageRaw(msg);
         } catch (const std::exception & e) {
           RCLCPP_ERROR(this->get_logger(), "Exception in onMultiImageRaw callback: %s", e.what());
         }
       },
       options);
-    RCLCPP_INFO(this->get_logger(), "Subscribed to MultiImageRaw (uncompressed) topic: %s", input_topic_raw_.c_str());
+    RCLCPP_INFO(this->get_logger(), "Subscribed to MultiImage (uncompressed) topic: %s", input_topic_raw_.c_str());
   }
 }
 
@@ -435,7 +435,7 @@ cv::Mat DeepObjectDetectionNode::decodeImage(const sensor_msgs::msg::Image & img
   }
 }
 
-void DeepObjectDetectionNode::onMultiImage(const deep_msgs::msg::MultiImage::ConstSharedPtr & msg)
+void DeepObjectDetectionNode::onMultiImage(const deep_msgs::msg::MultiImageCompressed::ConstSharedPtr & msg)
 {
   RCLCPP_DEBUG(this->get_logger(), "Received MultiImage message with %zu images", msg->images.size());
   try {
@@ -465,9 +465,9 @@ void DeepObjectDetectionNode::onMultiImage(const deep_msgs::msg::MultiImage::Con
   }
 }
 
-void DeepObjectDetectionNode::onMultiImageRaw(const deep_msgs::msg::MultiImageRaw::ConstSharedPtr & msg)
+void DeepObjectDetectionNode::onMultiImageRaw(const deep_msgs::msg::MultiImage::ConstSharedPtr & msg)
 {
-  RCLCPP_DEBUG(this->get_logger(), "Received MultiImageRaw message with %zu images", msg->images.size());
+  RCLCPP_DEBUG(this->get_logger(), "Received MultiImage message with %zu images", msg->images.size());
   try {
     std::vector<cv::Mat> images;
     std::vector<std_msgs::msg::Header> headers;
@@ -487,10 +487,10 @@ void DeepObjectDetectionNode::onMultiImageRaw(const deep_msgs::msg::MultiImageRa
     if (!images.empty()) {
       processImages(images, headers);
     } else {
-      RCLCPP_WARN(this->get_logger(), "No valid images after decoding, skipping MultiImageRaw");
+      RCLCPP_WARN(this->get_logger(), "No valid images after decoding, skipping MultiImage");
     }
   } catch (const std::exception & e) {
-    RCLCPP_ERROR(this->get_logger(), "Exception processing MultiImageRaw: %s", e.what());
+    RCLCPP_ERROR(this->get_logger(), "Exception processing MultiImage: %s", e.what());
   }
 }
 

deep_object_detection/src/deep_object_detection_node.cpp

@@ -28,7 +28,7 @@
 import numpy as np
 import pytest
 import rclpy
-from deep_msgs.msg import MultiImage
+from deep_msgs.msg import MultiImageCompressed
 from sensor_msgs.msg import CompressedImage
 from std_msgs.msg import Header
 from vision_msgs.msg import Detection2DArray
@@ -126,7 +126,7 @@ def test_detection_with_dummy_multiimage(self, proc_output):
 
         # Create publisher for MultiImage messages
         multi_image_pub = self.node.create_publisher(
-            MultiImage, "/multi_camera_sync/multi_image_compressed", 10
+            MultiImageCompressed, "/multi_camera_sync/multi_image_compressed", 10
         )
 
         # Variable to track if we received detections
@@ -158,7 +158,7 @@ def detection_callback(msg):
 
         # Create MultiImage message with 1 image (for testing)
         # Note: max_batch_size is 6, but node will process when batch timer fires
-        multi_image_msg = MultiImage()
+        multi_image_msg = MultiImageCompressed()
         multi_image_msg.header = Header()
         multi_image_msg.header.stamp = self.node.get_clock().now().to_msg()
         multi_image_msg.header.frame_id = "camera"

deep_object_detection/test/launch_tests/test_deep_object_detection_cpu_backend.py

@@ -33,7 +33,7 @@
 import numpy as np
 import pytest
 import rclpy
-from deep_msgs.msg import MultiImage
+from deep_msgs.msg import MultiImageCompressed
 from sensor_msgs.msg import CompressedImage
 from std_msgs.msg import Header
 from vision_msgs.msg import Detection2DArray
@@ -139,7 +139,7 @@ def test_gpu_detection_with_dummy_multiimage(self, proc_output):
 
         # Create publisher for MultiImage messages
         multi_image_pub = self.node.create_publisher(
-            MultiImage, "/multi_camera_sync/multi_image_compressed", 10
+            MultiImageCompressed, "/multi_camera_sync/multi_image_compressed", 10
         )
 
         # Variable to track if we received detections
@@ -166,7 +166,7 @@ def detection_callback(msg):
         _, encoded_image = cv2.imencode(".jpg", dummy_image, encode_param)
 
         # Create MultiImage message with 1 image
-        multi_image_msg = MultiImage()
+        multi_image_msg = MultiImageCompressed()
         multi_image_msg.header = Header()
         multi_image_msg.header.stamp = self.node.get_clock().now().to_msg()
         multi_image_msg.header.frame_id = "camera"