### ---[ PCL global CMake cmake_minimum_required(VERSION 3.10 FATAL_ERROR) if(POLICY CMP0074) # 1. Remove with 3.12.4. # 2. Remove search paths with *_ROOT since they will be automatically checked cmake_policy(SET CMP0074 NEW) endif() # Set target C++ standard and required compiler features set(CMAKE_CXX_STANDARD 14 CACHE STRING "The target C++ standard. PCL requires C++14 or higher.") set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_EXTENSIONS OFF) set(PCL_CXX_COMPILE_FEATURES cxx_std_14) set(CMAKE_CUDA_STANDARD 14 CACHE STRING "The target CUDA/C++ standard. PCL requires CUDA/C++ 14 or higher.") set(CMAKE_CUDA_STANDARD_REQUIRED ON) set(CMAKE_CONFIGURATION_TYPES "Debug;Release" CACHE STRING "possible configurations" FORCE) # In case the user does not setup CMAKE_BUILD_TYPE, assume it's RelWithDebInfo if("${CMAKE_BUILD_TYPE}" STREQUAL "") set(CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING "build type default to RelWithDebInfo, set to Release to improve performance" FORCE) endif() project(PCL VERSION 1.14.0.99) string(TOLOWER ${PROJECT_NAME} PROJECT_NAME_LOWER) if(MSVC AND ("${MSVC_VERSION}" LESS 1910)) message(FATAL_ERROR "The compiler versions prior to Visual Studio version 2017 are not supported. Please upgrade to a newer version or another compiler!") endif() ### ---[ Find universal dependencies set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules/" ${CMAKE_MODULE_PATH}) # ---[ Include pkgconfig include(FindPkgConfig) if(WIN32 AND NOT MINGW) set(CMAKE_DEBUG_POSTFIX "d" CACHE STRING "Add postfix to target for Debug build.") set(CMAKE_RELEASE_POSTFIX "" CACHE STRING "Add postfix to target for Release build.") set(CMAKE_RELWITHDEBINFO_POSTFIX "rd" CACHE STRING "Add postfix to target for RelWithDebInfo build.") set(CMAKE_MINSIZEREL_POSTFIX "s" CACHE STRING "Add postfix to target for MinSizeRel build") endif() # Update the documentation string of CMAKE_BUILD_TYPE for GUIs set(CMAKE_BUILD_TYPE "${CMAKE_BUILD_TYPE}" CACHE STRING "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel." FORCE) # Compiler identification # Define a variable CMAKE_COMPILER_IS_X where X is the compiler short name. # Note: CMake automatically defines one for GNUCXX, nothing to do in this case. if(CMAKE_CXX_COMPILER_ID MATCHES "Clang") set(CMAKE_COMPILER_IS_CLANG 1) elseif(__COMPILER_PATHSCALE) set(CMAKE_COMPILER_IS_PATHSCALE 1) elseif(MSVC) set(CMAKE_COMPILER_IS_MSVC 1) elseif(MINGW) set(CMAKE_COMPILER_IS_MINGW 1) endif() # https://github.com/fish-shell/fish-shell/issues/5865 include(CheckCXXSourceCompiles) CHECK_CXX_SOURCE_COMPILES(" #include struct big { int foo[64]; }; std::atomic x; int main() { return x.load().foo[13]; }" LIBATOMIC_NOT_NEEDED) IF (NOT LIBATOMIC_NOT_NEEDED) SET(ATOMIC_LIBRARY "atomic") ENDIF() # Create a variable with expected default CXX flags # This will be used further down the road to check if the user explicitly provided CXX flags if(CMAKE_COMPILER_IS_MSVC) set(CMAKE_CXX_FLAGS_DEFAULT "/DWIN32 /D_WINDOWS /W3 /GR /EHsc") else() set(CMAKE_CXX_FLAGS_DEFAULT "") endif() include("${PCL_SOURCE_DIR}/cmake/pcl_verbosity.cmake") include("${PCL_SOURCE_DIR}/cmake/pcl_targets.cmake") include("${PCL_SOURCE_DIR}/cmake/pcl_options.cmake") include("${PCL_SOURCE_DIR}/cmake/clang-format.cmake") if(${PCL_ENABLE_CCACHE}) include (UseCompilerCache) UseCompilerCache(ccache REQUIRED) endif() # Enable verbose timing display? if(CMAKE_TIMING_VERBOSE AND UNIX) set_property(GLOBAL PROPERTY RULE_MESSAGES OFF) set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "${CMAKE_SOURCE_DIR}/cmake/custom_output.sh") endif() # check for SSE flags include("${PCL_SOURCE_DIR}/cmake/pcl_find_sse.cmake") if(PCL_ENABLE_SSE AND "${CMAKE_CXX_FLAGS}" STREQUAL "${CMAKE_CXX_FLAGS_DEFAULT}") PCL_CHECK_FOR_SSE() endif() # check for AVX flags if(PCL_ENABLE_AVX AND "${CMAKE_CXX_FLAGS}" STREQUAL "${CMAKE_CXX_FLAGS_DEFAULT}") include("${PCL_SOURCE_DIR}/cmake/pcl_find_avx.cmake") PCL_CHECK_FOR_AVX() endif() # ---[ Unix/Darwin/Windows specific flags if(CMAKE_COMPILER_IS_GNUCXX) if("${CMAKE_CXX_FLAGS}" STREQUAL "${CMAKE_CXX_FLAGS_DEFAULT}") if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 7) string(APPEND CMAKE_CXX_FLAGS " -Wabi=11") else() string(APPEND CMAKE_CXX_FLAGS " -Wabi") endif() string(APPEND CMAKE_CXX_FLAGS " -Wall -Wextra -fno-strict-aliasing ${SSE_FLAGS} ${AVX_FLAGS}") endif() if(PCL_WARNINGS_ARE_ERRORS) string(APPEND CMAKE_CXX_FLAGS " -Werror -fno-strict-aliasing") endif() if("${CMAKE_SHARED_LINKER_FLAGS}" STREQUAL "" AND NOT CMAKE_SYSTEM_NAME STREQUAL "Darwin") set(CMAKE_SHARED_LINKER_FLAGS "-Wl,--as-needed") endif() if(WIN32) if(PCL_SHARED_LIBS) string(APPEND CMAKE_SHARED_LINKER_FLAGS " -Wl,--export-all-symbols -Wl,--enable-auto-import") if(MINGW) add_definitions("-DBOOST_THREAD_USE_LIB") string(APPEND CMAKE_SHARED_LINKER_FLAGS " -Wl,--allow-multiple-definition") endif() else() add_definitions("-DBOOST_LIB_DIAGNOSTIC -DBOOST_THREAD_USE_LIB") endif() endif() endif() if(CMAKE_COMPILER_IS_MSVC) add_definitions("-DBOOST_ALL_NO_LIB -D_SCL_SECURE_NO_WARNINGS -D_CRT_SECURE_NO_WARNINGS -DNOMINMAX -DPCL_ONLY_CORE_POINT_TYPES ${SSE_DEFINITIONS}") if("${CMAKE_CXX_FLAGS}" STREQUAL "${CMAKE_CXX_FLAGS_DEFAULT}") string(APPEND CMAKE_CXX_FLAGS " /fp:precise ${SSE_FLAGS} ${AVX_FLAGS}") # Add extra code generation/link optimizations if(CMAKE_MSVC_CODE_LINK_OPTIMIZATION AND (NOT BUILD_CUDA) AND (NOT BUILD_GPU)) string(APPEND CMAKE_CXX_FLAGS_RELEASE " /GL") string(APPEND CMAKE_SHARED_LINKER_FLAGS_RELEASE " /LTCG /OPT:REF") string(APPEND CMAKE_EXE_LINKER_FLAGS_RELEASE " /LTCG") else() set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -Xcompiler=/bigobj") message("Global optimizations /GL has been turned off, as it doesn't work with nvcc/thrust") endif() # /MANIFEST:NO") # please, don't disable manifest generation, otherwise crash at start for vs2008 # Disable some warnings string(APPEND CMAKE_CXX_FLAGS " /wd4800 /wd4521 /wd4251 /wd4275 /wd4305 /wd4355") # Enable warnings, which are disabled by default (see https://learn.microsoft.com/de-de/cpp/preprocessor/compiler-warnings-that-are-off-by-default) string(APPEND CMAKE_CXX_FLAGS " /w34265") if(PCL_WARNINGS_ARE_ERRORS) # MSVC supports external includes only since Visual Studio 2019 version 16.10.0. # CMake supports external includes since 3.22.0 using the Ninja generator or NMake files (see https://gitlab.kitware.com/cmake/cmake/-/merge_requests/4766) # CMake supports external includes for Visual Studio also since 3.24.0 (see https://gitlab.kitware.com/cmake/cmake/-/merge_requests/7238) if(CMAKE_C_COMPILER_VERSION VERSION_LESS "19.29.30036.3" OR CMAKE_VERSION VERSION_LESS 3.22.0 OR (CMAKE_VERSION VERSION_LESS 3.24.0 AND CMAKE_GENERATOR MATCHES "Visual Studio")) message(WARNING "With the used combination of compiler and CMake version it is not recommended to activate PCL_WARNINGS_ARE_ERRORS, " "because also warnings from 3rd party components are marked as errors. It is recommended to upgrade to " "Visual Studio 2019 version 16.10.0 and CMake 3.24.0 (or CMake 3.22.0 if using Ninja or NMake files).") endif() string(APPEND CMAKE_CXX_FLAGS " /WX") endif() include(ProcessorCount) ProcessorCount(CPUCores) set(MSVC_MP ${CPUCores} CACHE STRING "Number of simultaneously running compilers (0 = automatic detection by MSVC). See documentation of /MP flag.") if (CMAKE_VERSION VERSION_LESS 3.11.0) # Usage of COMPILE_LANGUAGE generator expression for MSVC in add_compile_options requires at least CMake 3.11, see https://gitlab.kitware.com/cmake/cmake/issues/17435 if(MSVC_MP EQUAL 0) # MSVC_MP is 0 in case the information cannot be determined by ProcessorCount => fallback string(APPEND CMAKE_C_FLAGS " /MP") string(APPEND CMAKE_CXX_FLAGS " /MP") elseif(MSVC_MP GREATER 1) string(APPEND CMAKE_C_FLAGS " /MP${MSVC_MP}") string(APPEND CMAKE_CXX_FLAGS " /MP${MSVC_MP}") endif() else() if(MSVC_MP EQUAL 0) # MSVC_MP is 0 in case the information cannot be determined by ProcessorCount => fallback # Generator expression is necessary to limit /MP flag to C/CXX, so flag will be not set to e.g. CUDA (see https://gitlab.kitware.com/cmake/cmake/issues/17535) add_compile_options($<$,$>:/MP>) elseif(MSVC_MP GREATER 1) add_compile_options($<$,$>:/MP${MSVC_MP}>) endif() endif() endif() string(APPEND CMAKE_CXX_FLAGS " /bigobj") if(CMAKE_GENERATOR STREQUAL "Ninja") string(APPEND CMAKE_C_FLAGS " /FS") string(APPEND CMAKE_CXX_FLAGS " /FS") endif() endif() if(CMAKE_COMPILER_IS_PATHSCALE) if("${CMAKE_CXX_FLAGS}" STREQUAL "${CMAKE_CXX_FLAGS_DEFAULT}") set(CMAKE_CXX_FLAGS "-Wno-uninitialized -zerouv -mp") endif() if("${CMAKE_SHARED_LINKER_FLAGS}" STREQUAL "") set(CMAKE_SHARED_LINKER_FLAGS "-mp") endif() endif() if(CMAKE_COMPILER_IS_CLANG) if("${CMAKE_C_FLAGS}" STREQUAL "${CMAKE_CXX_FLAGS_DEFAULT}") set(CMAKE_C_FLAGS "-Qunused-arguments") endif() if("${CMAKE_CXX_FLAGS}" STREQUAL "") set(CMAKE_CXX_FLAGS "-ftemplate-depth=1024 -Qunused-arguments -Wno-invalid-offsetof ${SSE_FLAGS} ${AVX_FLAGS}") # Unfortunately older Clang versions do not have this: -Wno-unnamed-type-template-args if(APPLE AND WITH_CUDA AND CUDA_FOUND) string(APPEND CMAKE_CXX_FLAGS " -stdlib=libstdc++") endif() endif() set(CLANG_LIBRARIES "stdc++") endif() if(CMAKE_COMPILER_IS_MINGW) add_definitions(-DPCL_ONLY_CORE_POINT_TYPES) endif() include("${PCL_SOURCE_DIR}/cmake/pcl_utils.cmake") DISSECT_VERSION() GET_OS_INFO() SET_INSTALL_DIRS() if(WIN32) set(PCL_RESOURCES_DIR "${PCL_SOURCE_DIR}/resources") set(PCL_POINTCLOUDS_DIR "${PCL_RESOURCES_DIR}/pointclouds") endif() set(PCL_OUTPUT_LIB_DIR "${PCL_BINARY_DIR}/${LIB_INSTALL_DIR}") set(PCL_OUTPUT_BIN_DIR "${PCL_BINARY_DIR}/${BIN_INSTALL_DIR}") make_directory("${PCL_OUTPUT_LIB_DIR}") make_directory("${PCL_OUTPUT_BIN_DIR}") set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${PCL_OUTPUT_LIB_DIR}") set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${PCL_OUTPUT_BIN_DIR}") if(WIN32) set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${PCL_OUTPUT_BIN_DIR}") foreach(config ${CMAKE_CONFIGURATION_TYPES}) string(TOUPPER ${config} CONFIG) set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_${CONFIG} "${PCL_OUTPUT_LIB_DIR}") set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_${CONFIG} "${PCL_OUTPUT_BIN_DIR}") # ---[ Windows requires DLLs (shared libraries) to be installed in the same directory as executables set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_${CONFIG} "${PCL_OUTPUT_BIN_DIR}") endforeach() else() set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${PCL_OUTPUT_LIB_DIR}") endif() # Check if the current generator is an IDE. check_if_ide(CMAKE_GENERATOR_IS_IDE) # Add an "uninstall" target if(CMAKE_GENERATOR_IS_IDE) set(UNINSTALL_TARGET_NAME UNINSTALL) else() set(UNINSTALL_TARGET_NAME uninstall) endif() configure_file("${PCL_SOURCE_DIR}/cmake/uninstall_target.cmake.in" "${PCL_BINARY_DIR}/uninstall_target.cmake" IMMEDIATE @ONLY) add_custom_target(${UNINSTALL_TARGET_NAME} "${CMAKE_COMMAND}" -P "${PCL_BINARY_DIR}/uninstall_target.cmake") ### # this is copy paste form http://www.itk.org/Wiki/CMake_RPATH_handling # in order to always make a full statement RPATH ### set(CMAKE_SKIP_BUILD_RPATH FALSE) set(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE) set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${LIB_INSTALL_DIR}") set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE) LIST(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES "${CMAKE_INSTALL_PREFIX}/${LIB_INSTALL_DIR}" is_system_dir) if("${is_system_dir}" STREQUAL "-1") set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${LIB_INSTALL_DIR}") endif() ### ---[ Find universal dependencies # OpenMP (optional) option(WITH_OPENMP "Build with parallelization using OpenMP" TRUE) if(WITH_OPENMP) find_package(OpenMP COMPONENTS C CXX) endif() if(OpenMP_FOUND) string(APPEND CMAKE_C_FLAGS " ${OpenMP_C_FLAGS}") string(APPEND CMAKE_CXX_FLAGS " ${OpenMP_CXX_FLAGS}") # We could use OpenMP_CXX_VERSION starting from CMake 3.9, but this value is only available on first run of CMake (see https://gitlab.kitware.com/cmake/cmake/issues/19150), # so we use always OpenMP_CXX_SPEC_DATE, which is available since CMake 3.7. message(STATUS "Found OpenMP, spec date ${OpenMP_CXX_SPEC_DATE}") if((MSVC_VERSION EQUAL 1900) OR (MSVC_VERSION MATCHES "^191[0-9]$")) string(APPEND CMAKE_SHARED_LINKER_FLAGS_DEBUG " /DELAYLOAD:VCOMP140D.dll") string(APPEND CMAKE_SHARED_LINKER_FLAGS_RELEASE " /DELAYLOAD:VCOMP140.dll") endif() else() message(STATUS "Not found OpenMP") endif() # Threads (required) find_package(Threads REQUIRED) # Eigen3 (required) find_package(Eigen3 3.3 REQUIRED NO_MODULE) if(NOT EIGEN3_FOUND AND Eigen3_FOUND) set(EIGEN3_FOUND ${Eigen3_FOUND}) endif() # FLANN find_package(FLANN 1.9.1) if(NOT FLANN_FOUND) message(WARNING "Flann was not found, so many PCL modules will not be built!") else() if(NOT (${FLANN_LIBRARY_TYPE} MATCHES ${PCL_FLANN_REQUIRED_TYPE}) AND NOT (${PCL_FLANN_REQUIRED_TYPE} MATCHES "DONTCARE")) message(FATAL_ERROR "Flann was selected with ${PCL_FLANN_REQUIRED_TYPE} but found as ${FLANN_LIBRARY_TYPE}") endif() endif() # libusb option(WITH_LIBUSB "Build USB RGBD-Camera drivers" TRUE) if(WITH_LIBUSB) include("${PCL_SOURCE_DIR}/cmake/pcl_find_libusb.cmake") endif() # Dependencies for different grabbers PCL_ADD_GRABBER_DEPENDENCY("OpenNI" "OpenNI grabber support") PCL_ADD_GRABBER_DEPENDENCY("OpenNI2" "OpenNI2 grabber support") PCL_ADD_GRABBER_DEPENDENCY("Ensenso" "IDS-Imaging Ensenso camera support") PCL_ADD_GRABBER_DEPENDENCY("davidSDK" "David Vision Systems SDK support") PCL_ADD_GRABBER_DEPENDENCY("DSSDK" "DepthSense SDK support") PCL_ADD_GRABBER_DEPENDENCY("RSSDK" "RealSense SDK support") PCL_ADD_GRABBER_DEPENDENCY("RSSDK2" "RealSense SDK 2.0 (librealsense) support") # metslib if(PKG_CONFIG_FOUND) pkg_check_modules(METSLIB metslib) if(METSLIB_FOUND) set(HAVE_METSLIB ON) endif() endif() # LibPNG option(WITH_PNG "PNG file support" TRUE) if(WITH_PNG) find_package(PNG) if(PNG_FOUND) set(HAVE_PNG ON) endif() endif() # Qhull option(WITH_QHULL "Include convex-hull operations" TRUE) if(WITH_QHULL) find_package(Qhull) if(NOT (${QHULL_LIBRARY_TYPE} MATCHES ${PCL_QHULL_REQUIRED_TYPE}) AND NOT (${PCL_QHULL_REQUIRED_TYPE} MATCHES "DONTCARE")) message(FATAL_ERROR "Qhull was selected with ${PCL_QHULL_REQUIRED_TYPE} but found as ${QHULL_LIBRARY_TYPE}") endif() endif() # Cuda option(WITH_CUDA "Build NVIDIA-CUDA support" TRUE) if(WITH_CUDA) include("${PCL_SOURCE_DIR}/cmake/pcl_find_cuda.cmake") endif() # Reset VTK_FOUND to off set(VTK_FOUND OFF) # Find VTK - VTK has to be found before Qt, otherwise it can overwrite Qt variables option(WITH_VTK "Build VTK-Visualizations" TRUE) if(WITH_VTK) if(ANDROID) message(WARNING "VTK is not supported on Android.") else() include("${PCL_SOURCE_DIR}/cmake/pcl_find_vtk.cmake") endif() endif() # VTK can depend on Qt and search for its required version, so search after so we can overwrite Qt5_FOUND/Qt6_FOUND if the version we require is not found. set(WITH_QT "AUTO" CACHE STRING "Build QT Front-End (AUTO|YES|QT6|QT5|NO)") set_property(CACHE WITH_QT PROPERTY STRINGS "AUTO" "YES" "QT6" "QT5" "NO") if(WITH_QT) include("${PCL_SOURCE_DIR}/cmake/pcl_find_qt.cmake") endif() #Find PCAP option(WITH_PCAP "pcap file capabilities in Velodyne HDL driver" TRUE) if(WITH_PCAP) find_package(Pcap) endif() # OpenGL and GLUT option(WITH_OPENGL "Support for OpenGL" TRUE) if(WITH_OPENGL) include("${PCL_SOURCE_DIR}/cmake/pcl_find_gl.cmake") endif() # GLEW option(WITH_GLEW "Support for GLEW" TRUE) if(WITH_GLEW) find_package(GLEW QUIET) endif() # Boost (required) include("${PCL_SOURCE_DIR}/cmake/pcl_find_boost.cmake") # System zlib (for nurbs on surface) option(WITH_SYSTEM_ZLIB "Use system zlib" TRUE) if(WITH_SYSTEM_ZLIB) find_package(ZLIB) if(ZLIB_FOUND) set(HAVE_ZLIB ON) endif() endif() ### ---[ Create the config.h file set(pcl_config_h_in "${CMAKE_CURRENT_SOURCE_DIR}/pcl_config.h.in") set(pcl_config_h "${CMAKE_CURRENT_BINARY_DIR}/include/pcl/pcl_config.h") configure_file("${pcl_config_h_in}" "${pcl_config_h}") PCL_ADD_INCLUDES(common "" "${pcl_config_h}") include_directories("${CMAKE_CURRENT_BINARY_DIR}/include") collect_subproject_directory_names("${PCL_SOURCE_DIR}" "CMakeLists.txt" PCL_MODULES_NAMES PCL_MODULES_DIRS doc) set(PCL_MODULES_NAMES_UNSORTED ${PCL_MODULES_NAMES}) topological_sort(PCL_MODULES_NAMES PCL_ _DEPENDS) sort_relative(PCL_MODULES_NAMES_UNSORTED PCL_MODULES_NAMES PCL_MODULES_DIRS) foreach(subdir ${PCL_MODULES_DIRS}) add_subdirectory("${PCL_SOURCE_DIR}/${subdir}") endforeach() ### ---[ Documentation add_subdirectory(doc) ### ---[ Configure PCLConfig.cmake include("${PCL_SOURCE_DIR}/cmake/pcl_pclconfig.cmake") ### ---[ Package creation include("${PCL_SOURCE_DIR}/cmake/pcl_all_in_one_installer.cmake") include("${PCL_SOURCE_DIR}/cmake/pcl_cpack.cmake") if(CPACK_GENERATOR) message(STATUS "Found CPack generators: ${CPACK_GENERATOR}") PCL_MAKE_CPACK_INPUT() set(CPACK_PROJECT_CONFIG_FILE "${PCL_CPACK_CFG_FILE}") include(CPack) endif() ### ---[ Make a pretty picture of the dependency graph include("${PCL_SOURCE_DIR}/cmake/dep_graph.cmake") MAKE_DEP_GRAPH() ### ---[ Finish up PCL_WRITE_STATUS_REPORT() PCL_RESET_MAPS()