Fixed structurre of CMakeLists and package.xml and logged with console bridge

Author: IasonTheodorou

CMakeLists.txt

@@ -3,19 +3,17 @@ cmake_minimum_required(VERSION 3.14)
 project(sam_onnx_ros)
 
 # -------------- CMake Policies ------------------#
-#add_compile_options(-Wall -Werror=all)
-#add_compile_options(-Wextra -Werror=extra)
+# add_compile_options(-Wall -Werror=all)
+# add_compile_options(-Wextra -Werror=extra)
 
 # -------------- Support C++17 for using filesystem  ------------------#
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
-set(CMAKE_CXX_EXTENSIONS ON)
-#set(CMAKE_INCLUDE_CURRENT_DIR ON)
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
 # -------------- OpenCV  ------------------#
 find_package(OpenCV REQUIRED)
-include_directories(${OpenCV_INCLUDE_DIRS})
-
+find_package(console_bridge REQUIRED)
 
 # -------------- ONNXRuntime  ------------------#
 set(ONNXRUNTIME_VERSION 1.21.0)
@@ -26,94 +24,124 @@ include_directories(${ONNXRUNTIME_ROOT}/include)
 add_definitions(-DUSE_CUDA=1)
 include_directories(/usr/local/cuda/include)
 
+# -------------- Models ------------------#
+# TODO: Find proper folder Copy sam_<model>.onnx file to the same folder of the executable file
+configure_file(~/Documents/repos/hero_sam.bak/sam_inference/model/SAM_mask_decoder.onnx ${CMAKE_CURRENT_BINARY_DIR}/SAM_mask_decoder.onnx  COPYONLY)
+configure_file(~/Documents/repos/hero_sam.bak/sam_inference/model/SAM_encoder.onnx ${CMAKE_CURRENT_BINARY_DIR}/SAM_encoder.onnx COPYONLY)
+
+
 find_package(catkin REQUIRED
   COMPONENTS
-  # roscpp
-  # tue_config
-  # tue_filesystem
-  # code_profiler
-
+  rosconsole
+  console_bridge
   #onnxruntime_ros
 )
 
+find_package(console_bridge REQUIRED)
+
 # ------------------------------------------------------------------------------------------------
 #                                        CATKIN EXPORT
 # ------------------------------------------------------------------------------------------------
 
 catkin_package(
   INCLUDE_DIRS include
-  #LIBRARIES ${PROJECT_NAME}
-  LIBRARIES sam_onnx_ros_core
+  LIBRARIES ${PROJECT_NAME}_lib
   CATKIN_DEPENDS
-  DEPENDS OpenCV
+  DEPENDS OpenCV console_bridge
 )
 
 # ------------------------------------------------------------------------------------------------
 #                                           BUILD
 # ------------------------------------------------------------------------------------------------
 
-include_directories(
-  include
-  SYSTEM
-  ${OpenCV_INCLUDE_DIRS}
-  ${catkin_INCLUDE_DIRS}
-)
-
-set(PROJECT_SOURCES
-        src/main.cpp
+# Build core library
+add_library(${PROJECT_NAME}_lib
         src/sam_inference.cpp
         src/segmentation.cpp
         src/utils.cpp
 )
 
-# Build core library (no main.cpp here)
-add_library(sam_onnx_ros_core
-        src/sam_inference.cpp
-        src/segmentation.cpp
-        src/utils.cpp
+target_include_directories(${PROJECT_NAME}_lib
+  PUBLIC
+    include
+    SYSTEM
+    ${OpenCV_INCLUDE_DIRS}
+    ${catkin_INCLUDE_DIRS}
+    ${console_bridge_INCLUDE_DIRS}
+    ${ONNXRUNTIME_ROOT}/include
 )
-target_link_libraries(sam_onnx_ros_core
+
+
+target_link_libraries(${PROJECT_NAME}_lib
     ${OpenCV_LIBS}
     ${catkin_LIBRARIES}
     ${ONNXRUNTIME_ROOT}/lib/libonnxruntime.so
 )
-target_include_directories(sam_onnx_ros_core PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
 
 # Main executable links the core lib
-add_executable(${PROJECT_NAME} src/main.cpp)
-target_link_libraries(${PROJECT_NAME} sam_onnx_ros_core)
+add_executable(${PROJECT_NAME}
+  src/main.cpp
+)
 
-# Copy sam_<model>.onnx file to the same folder of the executable file
-configure_file(~/Documents/repos/hero_sam.bak/sam_inference/model/SAM_mask_decoder.onnx ${CMAKE_CURRENT_BINARY_DIR}/SAM_mask_decoder.onnx  COPYONLY)
-configure_file(~/Documents/repos/hero_sam.bak/sam_inference/model/SAM_encoder.onnx ${CMAKE_CURRENT_BINARY_DIR}/SAM_encoder.onnx COPYONLY)
+target_link_libraries(${PROJECT_NAME}
+  ${PROJECT_NAME}_lib
+  ${catkin_LIBRARIES}
+  ${ONNXRUNTIME_ROOT}/lib/libonnxruntime.so
+)
+
+# ------------------------------------------------------------------------------------------------
+#                                           Install Targets
+# ------------------------------------------------------------------------------------------------
+
+install(
+  DIRECTORY include/
+  DESTINATION ${CATKIN_GLOBAL_INCLUDE_DESTINATION}
+)
 
-# Create folder name images in the same folder of the executable file
-add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
-    COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/images
+install(
+  TARGETS
+    ${PROJECT_NAME}_lib
+  ARCHIVE DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION}
+  LIBRARY DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION}
+  RUNTIME DESTINATION ${CATKIN_GLOBAL_BIN_DESTINATION}
 )
 
-# # Enable testing
+install(
+  TARGETS
+    ${PROJECT_NAME}
+  DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
+)
+
+# ------------------------------------------------------------------------------------------------
+#                                           Testing
+# ------------------------------------------------------------------------------------------------
 if (CATKIN_ENABLE_TESTING)
-#   find_package(catkin_lint_cmake REQUIRED)
-#   catkin_add_catkin_lint_test("-W2 --ignore HEADER_OUTSIDE_PACKAGE_INCLUDE_PATH")
+  find_package(catkin_lint_cmake REQUIRED)
+  catkin_add_catkin_lint_test("-W2 --ignore HEADER_OUTSIDE_PACKAGE_INCLUDE_PATH")
 
- # Utils unit tests (no models needed)
+  # Utils unit tests (no models needed)
   catkin_add_gtest(utils_tests test/test_utils.cpp)
   if(TARGET utils_tests)
-    target_link_libraries(utils_tests sam_onnx_ros_core GTest::gtest_main ${catkin_LIBRARIES})
-    target_include_directories(utils_tests PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
+    target_link_libraries(
+      utils_tests
+      ${PROJECT_NAME}_lib
+      ${catkin_LIBRARIES}
+      GTest::gtest
+      GTest::gtest_main
+      )
+    #target_include_directories(utils_tests PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
   endif()
 
   # SAM integration-ish tests (may need models)
   catkin_add_gtest(sam_tests test/sam_test.cpp)
   if(TARGET sam_tests)
-    target_link_libraries(sam_tests sam_onnx_ros_core GTest::gtest_main ${catkin_LIBRARIES})
-    target_include_directories(sam_tests PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
+    target_link_libraries(
+      sam_tests
+      ${PROJECT_NAME}_lib
+      ${catkin_LIBRARIES}
+      GTest::gtest
+      GTest::gtest_main
+    )
+    #target_include_directories(sam_tests PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
   endif()
 endif()
-
-
-
-#If you want to debug
-# set(CMAKE_BUILD_TYPE Debug)
-# set(CMAKE_CXX_FLAGS_DEBUG "-g")

package.xml

@@ -12,13 +12,18 @@
 
   <license>BSD</license>
 
+
   <buildtool_depend>catkin</buildtool_depend>
 
+  <depend>libconsole-bridge-dev</depend>
+
   <build_depend>libopencv-dev</build_depend>
   <build_depend>onnxruntime_ros</build_depend>
+  <build_depend>rosconsole</build_depend>
 
   <exec_depend>libopencv-dev</exec_depend>
   <exec_depend>onnxruntime_ros</exec_depend>
+  <exec_depend>rosconsole</exec_depend>
 
   <test_depend>catkin_lint_cmake</test_depend>
 

src/sam_inference.cpp

@@ -1,6 +1,8 @@
 #include "sam_inference.h"
 #include "utils.h"
+
 #include <regex>
+#include <console_bridge/console.h>
 
 #define benchmark
 //#define ROI
@@ -50,7 +52,7 @@ const char *SAM::CreateSession(SEG::DL_INIT_PARAM &iParams) {
   if (result) {
     Ret = "[SAM]:Your model path is error.Change your model path without "
           "chinese characters.";
-    std::cout << Ret << std::endl;
+    CONSOLE_BRIDGE_logWarn("%s", Ret);
     return Ret;
   }
   try {
@@ -109,7 +111,7 @@ const char *SAM::CreateSession(SEG::DL_INIT_PARAM &iParams) {
     std::string str_result = std::string(str1) + std::string(str2);
     char *merged = new char[str_result.length() + 1];
     std::strcpy(merged, str_result.c_str());
-    std::cout << merged << std::endl;
+    CONSOLE_BRIDGE_logWarn("%s", merged);
     delete[] merged;
     return "[SAM]:Create _session failed.";
   }
@@ -190,13 +192,17 @@ const char *SAM::TensorProcess_(clock_t &starttime_1, const cv::Mat &iImg,
       double post_process_time =
           (double)(starttime_4 - starttime_3) / CLOCKS_PER_SEC * 1000;
       if (_cudaEnable) {
-        std::cout << "[SAM_encoder(CUDA)]: " << pre_process_time << "ms pre-process, "
-                  << process_time << "ms inference, " << post_process_time
-                  << "ms post-process." << std::endl;
+        CONSOLE_BRIDGE_logInform("[SAM_encoder(CUDA)]: %.2fms pre-process, %.2fms inference, "
+                               "%.2fms post-process.",
+                               pre_process_time, process_time,
+                               post_process_time
+                                );
       } else {
-        std::cout << "[SAM_encoder(CPU)]: " << pre_process_time << "ms pre-process, "
-                  << process_time << "ms inference, " << post_process_time
-                  << "ms post-process." << std::endl;
+        CONSOLE_BRIDGE_logInform("[SAM_encoder(CPU)]: %.2fms pre-process, %.2fms inference, "
+                               "%.2fms post-process.",
+                               pre_process_time, process_time,
+                               post_process_time
+                                );
       }
 #endif // benchmark
 
@@ -305,20 +311,24 @@ const char *SAM::TensorProcess_(clock_t &starttime_1, const cv::Mat &iImg,
     double post_process_time =
         (double)(starttime_4 - starttime_3) / CLOCKS_PER_SEC * 1000;
     if (_cudaEnable) {
-      std::cout << "[SAM_decoder(CUDA)]: " << pre_process_time << "ms pre-process, "
-                << process_time << "ms inference, " << post_process_time
-                << "ms post-process." << std::endl;
+      CONSOLE_BRIDGE_logInform("[SAM_decoder(CUDA)]: %.2fms pre-process, %.2fms inference, "
+                             "%.2fms post-process.",
+                             pre_process_time, process_time,
+                             post_process_time
+                              );
     } else {
-      std::cout << "[SAM_decoder(CPU)]: " << pre_process_time << "ms pre-process, "
-                << process_time << "ms inference, " << post_process_time
-                << "ms post-process." << std::endl;
+      CONSOLE_BRIDGE_logInform("[SAM_decoder(CPU)]: %.2fms pre-process, %.2fms inference, "
+                             "%.2fms post-process.",
+                             pre_process_time, process_time,
+                             post_process_time
+                              );
     }
 #endif // benchmark
     break;
   }
 
   default:
-    std::cout << "[SAM]: " << "Not support model type." << std::endl;
+    CONSOLE_BRIDGE_logWarn("[SAM]: " "Not support model type.");
   }
   return RET_OK;
 }
@@ -350,8 +360,7 @@ char *SAM::WarmUpSession_(SEG::MODEL_TYPE _modelType)
     double post_process_time =
         (double)(starttime_4 - starttime_1) / CLOCKS_PER_SEC * 1000;
     if (_cudaEnable) {
-      std::cout << "[SAM(CUDA)]: " << "Cuda warm-up cost " << post_process_time
-                << " ms. " << std::endl;
+      CONSOLE_BRIDGE_logInform("[SAM(CUDA)]: Cuda warm-up cost %.2f ms.", post_process_time);
     }
     break;
   }
@@ -417,8 +426,7 @@ char *SAM::WarmUpSession_(SEG::MODEL_TYPE _modelType)
     double post_process_time =
         (double)(starttime_4 - starttime_1) / CLOCKS_PER_SEC * 1000;
     if (_cudaEnable) {
-      std::cout << "[SAM(CUDA)]: " << "Cuda warm-up cost " << post_process_time
-                << " ms. " << std::endl;
+      CONSOLE_BRIDGE_logInform("[SAM(CUDA)]: Cuda warm-up cost %.2f ms.", post_process_time);
     }
 
     break;