Exploring CMakeLists: ROS and Catkin

Introduction to CMakeListsCMakeLists.txt file is the input file for the CMake build system used to build software packages. Any package that conforms to the CMake specification contains one or more CMakeLists.txt files that describe how to build the code and where to install it. The CMakeLists.txt file used for catkin projects is a standard CMakeLists.txt file but with some additional constraints.

Your CMakeLists.txt file must follow this format; otherwise, your package will not build correctly. The order of configuration is important.

Required CMake version (cmake_minimum_required)
Package name (project())
Find additional CMake/Catkin packages required for building (find_package())
Enable Python module support (catkin_python_setup())
Message / Service / Action generators (add_message_files(), add_service_files(), add_action_files())
Call message / service / action generation (generate_messages())
Specify package build information export (catkin_package())
Libraries / Executables to build (add_library()/add_executable()/target_link_libraries())
Tests to build (catkin_add_gtest())
Installation rules (install())

Below is an example of the CMakeLists for fast_lio

cmake_minimum_required(VERSION 2.8.3)
project(fast_lio)
# Specify the minimum CMake version and project name
SET(CMAKE_BUILD_TYPE "Debug")
# Compilation type, also can be release for more optimization
ADD_COMPILE_OPTIONS(-std=c++14 )
ADD_COMPILE_OPTIONS(-std=c++14 )
set( CMAKE_CXX_FLAGS "-std=c++14 -O3" )
add_definitions(-DROOT_DIR=\"${CMAKE_CURRENT_SOURCE_DIR}/\")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fexceptions" )
set(CMAKE_CXX_STANDARD 14)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -pthread -std=c++0x -std=c++14 -fexceptions")
message("Current CPU architecture: ${CMAKE_SYSTEM_PROCESSOR}")
if(CMAKE_SYSTEM_PROCESSOR MATCHES "(x86)|(X86)|(amd64)|(AMD64)" )
  include(ProcessorCount)
  ProcessorCount(N)
  message("Processor number:  ${N}")
  if(N GREATER 4)
    add_definitions(-DMP_EN)
    add_definitions(-DMP_PROC_NUM=3)
    message("core for MP: 3")
  elseif(N GREATER 3)
    add_definitions(-DMP_EN)
    add_definitions(-DMP_PROC_NUM=2)
    message("core for MP: 2")
  else()
    add_definitions(-DMP_PROC_NUM=1)
  endif()
else()
  add_definitions(-DMP_PROC_NUM=1)
endif()

find_package(OpenMP QUIET)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}   ${OpenMP_C_FLAGS}")
#find_package(PythonLibs REQUIRED)
find_path(MATPLOTLIB_CPP_INCLUDE_DIRS "matplotlibcpp.h")

If your project depends on other "wet" packages (packages that need to be compiled), at the CMake level, they automatically become components of catkin. Instead of using find_package for these packages individually, it is more convenient to specify them as components. For example, if you use the

geometry_msgs package:


find_package(catkin REQUIRED COMPONENTS  geometry_msgs  nav_msgs  sensor_msgs  roscpp  rospy  std_msgs  pcl_ros  tf  livox_ros_driver2  message_generation  eigen_conversions)
find_package(Eigen3 REQUIRED)
find_package(PCL 1.8 REQUIRED)
message(Eigen: ${EIGEN3_INCLUDE_DIR})
include_directories(  ${catkin_INCLUDE_DIRS}   ${EIGEN3_INCLUDE_DIR}  ${PCL_INCLUDE_DIRS}  ${PYTHON_INCLUDE_DIRS}  include)
add_message_files(  FILES  Pose6D.msg)
generate_messages( DEPENDENCIES geometry_msgs)
catkin_package(  CATKIN_DEPENDS geometry_msgs nav_msgs roscpp rospy std_msgs message_runtime  DEPENDS EIGEN3 PCL  INCLUDE_DIRS)
add_executable(fastlio_mapping src/laserMapping.cpp include/ikd-Tree/ikd_Tree.cpp src/preprocess.cpp)target_link_libraries(fastlio_mapping ${catkin_LIBRARIES} ${PCL_LIBRARIES} ${PYTHON_LIBRARIES})target_include_directories(fastlio_mapping PRIVATE ${PYTHON_INCLUDE_DIRS})

If CMake finds a package through find_package, it creates several CMake environment variables that provide information about the found package. These environment variables can be used in subsequent CMake scripts. They describe the location of the exported header files, source files, libraries that the package depends on, and the paths to these libraries. The variable names always follow the convention <package_name>_<property>:

<name>_FOUND: Set to true if the library is found, otherwise false.
<name>_INCLUDE_DIRS or <name>_INCLUDES: The include paths exported by the package.
<name>_LIBRARIES or <name>_LIBS: The libraries exported by the package.
<name>_DEFINITIONS: Definition information.

Why should Catkin packages be specified as components?

Catkin packages are not actually components of catkin. Instead, they utilize CMake’s component functionality in the design of catkin to save you a lot of input time.

For Catkin packages, if you use them as components of catkin with find_package, the benefit is that a set of environment variables prefixed with catkin_ will be created. For example, suppose you use the nodelet package in your code. The recommended way to find the package is

find_package(catkin REQUIRED COMPONENTS nodelet)

This means that the exported include paths, libraries, etc., of nodelet will also be appended to the catkin_ variables. For example, catkin_INCLUDE_DIRS will not only include the include paths of catkin but also those of nodelet! This will be very useful later.

We can also use find_package separately to find nodelet

This means that the paths, libraries, etc., of nodelet will not be added to the catkin_ variables.

This will produce variables like nodelet_INCLUDE_DIRS, nodelet_LIBRARIES, etc. Using the following method will also create the same variables

find_package(catkin REQUIRED COMPONENTS nodelet)

catkin_package() is a CMake macro provided by catkin. This is necessary to specify catkin-specific information to the build system, which in turn is used to generate pkg-config and CMake files.

This function must be called before declaring any targets using add_library() or add_executable(). This function has 5 optional parameters:

INCLUDE_DIRS: The include paths exported by the package (i.e., compilation flags).
LIBRARIES: The libraries exported by the project.
CATKIN_DEPENDS: Other catkin projects that this project depends on.
DEPENDS: Non-catkin CMake projects that this project depends on. For better understanding, please refer to this explanation.
CFG_EXTRAS: Additional configuration options

catkin_package(   INCLUDE_DIRS include   LIBRARIES ${PROJECT_NAME}   CATKIN_DEPENDS roscpp nodelet   DEPENDS eigen opencv)

This indicates that the include folder within the package folder is where the exported header files are located. The value of the CMake environment variable ${PROJECT_NAME} is the content you previously passed to the project() function, which in this case is robot_brain.roscpp and nodelet are the packages required to build/run this package, while eigen and opencv are the system dependencies required to build/run this package.

Include paths and library paths

Before specifying targets, you need to specify where to find the resources required for these targets, especially header files and libraries:

Include paths: Where the code being built (most commonly in C/C++) can find header files.
Library paths: Where the libraries that the executable targets depend on are located.

include_directories(<directory 1>, <directory 2>, ..., <directory N>)
link_directories(<directory 1>, <directory 2>, ..., <directory N>)

To specify the executable targets that must be built, we must use CMake’s add_executable() function

add_executable(myProgram src/main.cpp src/some_file.cpp src/another_file.cpp)

This will build an executable target named myProgram that is built from 3 source files:src/main.cpp, src/some_file.cpp, and src/another_file.cpp.

`target_link_libraries`

Use the target_link_libraries() function to specify the libraries that the executable target should link against. This is usually done after calling add_executable(). If ROS is not found, add ${catkin_LIBRARIES}

Messages (.msg), services (.srv), and actions (.action) in ROS require a special preprocessing build step before they can be built and used by ROS packages. These macros generate language-specific files so that users can use messages, services, and actions in their chosen programming language. The build system will use all available generators (e.g., gencpp, genpy, genlisp, etc.) to generate bindings.

Three macros are provided to handle messages, services, and actions:

add_message_files
add_service_files
add_action_files

Then a macro must be called to trigger the generation process:generate_messages()For detailed information, see

https://wiki.ros.org/catkin/CMakeLists.txt

—

CMAKE_PREFIX_PATH is an important environment variable in CMake that plays a key role when CMake searches for resources such as dependent libraries, header files, and executables. Here is a detailed introduction:

1. Basic Concept

CMAKE_PREFIX_PATH is a list of multiple paths, separated by colons : in Unix/Linux systems and semicolons ; in Windows systems. When CMake performs search operations, it refers to the paths specified by this variable to locate the required resources.

2. Working Mechanism

When you use search commands like find_package, find_library, find_path, find_file, etc., in the CMakeLists.txt file, CMake utilizes CMAKE_PREFIX_PATH in the following steps:

Traverse the path list: CMake checks each path in CMAKE_PREFIX_PATH sequentially.
Search for resources: For each path, CMake searches for the required resources in its specific subdirectories. For example, for library files, it typically looks in the lib subdirectory; for header files, it looks in the include subdirectory; for CMake configuration files, it looks in the lib/cmake or share/cmake subdirectory.

3. Specific Functions

3.1 Custom Library and Package Search

In actual development, you may use some custom libraries or third-party libraries that are not installed in the system’s default standard paths. In this case, you can add the installation paths of these libraries to CMAKE_PREFIX_PATH, so that CMake can find the required libraries and header files in these paths. For example, if you compiled a library named my_library and installed it in the /path/to/my_library directory, you can set CMAKE_PREFIX_PATH as follows:

export CMAKE_PREFIX_PATH=/path/to/my_library:$CMAKE_PREFIX_PATH

Then use find_package or find_library in the CMakeLists.txt to find this library

find_library(MY_LIBRARY my_library HINTS /path/to/my_library/lib)
if(MY_LIBRARY)    message(STATUS "Found my_library: ${MY_LIBRARY}")endif()

There may be multiple versions of the same library in the system, and by setting CMAKE_PREFIX_PATH, you can specify CMake to use a specific version of the library. Add the installation path of the library you want to use to the front of CMAKE_PREFIX_PATH, and CMake will prioritize searching for the required resources in that path.For example, if you have an old version of a library installed in /path/to/old_library and a new version installed in /path/to/new_library, if you want to use the new version of the library, you can set it as follows:

export CMAKE_PREFIX_PATH=/path/to/new_library:$CMAKE_PREFIX_PATH

All of the above are temporary settings; you can write them to bashrc for permanent handling.

Exploring CMakeLists: ROS and Catkin

Why should Catkin packages be specified as components?

Include paths and library paths

`<span>target_link_libraries</span>`

1. Basic Concept

2. Working Mechanism

3. Specific Functions

3.1 Custom Library and Package Search

Leave a Comment Cancel reply

Why should Catkin packages be specified as components?

Include paths and library paths

<span>target_link_libraries</span>

1. Basic Concept

2. Working Mechanism

3. Specific Functions

3.1 Custom Library and Package Search

Related posts

Leave a Comment Cancel reply

`<span>target_link_libraries</span>`