mirror of
https://github.com/introlab/rtabmap.git
synced 2026-09-02 09:30:25 +08:00
f647014f54
* Add FlannIndex abstract interface and implement NanoFlannIndex subclass * Refactored: made NanoFlann a new NN type instead of inheriting FlannIndex. Added tests. Vendoring nanoflann.h directly in the repo. RegistrationVis now use NANOFLANN_INDEX_KDTREE_SINGLE (instead of FLANN_INDEX_KDTREE_SINGLE) flann index for 2d points matching. * cleanup comments, added FlannIndex doxygen * Fixing windows tests * updating flaky test * Simplified interface, added flann kdtree single approach selectable by parameters. * RegVis: symmetry of nanoflann for two branches of guess feature matching * cv::BFMatcher baseline * Small cmake optimization FLANN_KDTREE_MEM_OPT only defined for FlannIndex * Refactored where FLANN_KDTREE_MEM_OPT is defined * fixed file name already exist * cleanup * fixup build --------- Co-authored-by: matlabbe <matlabbe@gmail.com>
987 lines
21 KiB
CMake
987 lines
21 KiB
CMake
|
|
SET(SRC_FILES
|
|
Rtabmap.cpp
|
|
RtabmapThread.cpp
|
|
|
|
Statistics.cpp
|
|
|
|
Memory.cpp
|
|
|
|
DBDriver.cpp
|
|
DBDriverSqlite3.cpp
|
|
DBReader.cpp
|
|
|
|
Recovery.cpp
|
|
|
|
SensorCapture.cpp
|
|
SensorCaptureThread.cpp
|
|
|
|
Camera.cpp
|
|
CameraModel.cpp
|
|
|
|
camera/CameraFreenect.cpp
|
|
camera/CameraFreenect2.cpp
|
|
camera/CameraImages.cpp
|
|
camera/CameraK4W2.cpp
|
|
camera/CameraK4A.cpp
|
|
camera/CameraOpenni.cpp
|
|
camera/CameraOpenNI2.cpp
|
|
camera/CameraOpenNICV.cpp
|
|
camera/CameraRealSense.cpp
|
|
camera/CameraRealSense2.cpp
|
|
camera/CameraRGBDImages.cpp
|
|
camera/CameraStereoDC1394.cpp
|
|
camera/CameraStereoFlyCapture2.cpp
|
|
camera/CameraStereoImages.cpp
|
|
camera/CameraStereoVideo.cpp
|
|
camera/CameraStereoZed.cpp
|
|
camera/CameraStereoZedOC.cpp
|
|
camera/CameraStereoTara.cpp
|
|
camera/CameraVideo.cpp
|
|
camera/CameraMyntEye.cpp
|
|
camera/CameraDepthAI.cpp
|
|
camera/CameraSeerSense.cpp
|
|
camera/CameraOrbbecSDK.cpp
|
|
|
|
EpipolarGeometry.cpp
|
|
VisualWord.cpp
|
|
VWDictionary.cpp
|
|
BayesFilter.cpp
|
|
Parameters.cpp
|
|
Signature.cpp
|
|
Features2d.cpp
|
|
Transform.cpp
|
|
GeodeticCoords.cpp
|
|
|
|
util2d.cpp
|
|
|
|
util3d.cpp
|
|
util3d_filtering.cpp
|
|
util3d_mapping.cpp
|
|
util3d_transforms.cpp
|
|
util3d_registration.cpp
|
|
util3d_surface.cpp
|
|
util3d_features.cpp
|
|
util3d_correspondences.cpp
|
|
util3d_motion_estimation.cpp
|
|
|
|
rvl_codec.cpp
|
|
|
|
SensorData.cpp
|
|
Graph.cpp
|
|
Compression.cpp
|
|
Link.cpp
|
|
LaserScan.cpp
|
|
|
|
Optimizer.cpp
|
|
optimizer/OptimizerTORO.cpp
|
|
optimizer/OptimizerG2O.cpp
|
|
optimizer/OptimizerGTSAM.cpp
|
|
optimizer/OptimizerCVSBA.cpp
|
|
optimizer/OptimizerCeres.cpp
|
|
|
|
Registration.cpp
|
|
RegistrationIcp.cpp
|
|
RegistrationVis.cpp
|
|
|
|
Odometry.cpp
|
|
OdometryThread.cpp
|
|
OdometryInfo.cpp
|
|
odometry/OdometryF2M.cpp
|
|
odometry/OdometryMono.cpp
|
|
odometry/OdometryF2F.cpp
|
|
odometry/OdometryFovis.cpp
|
|
odometry/OdometryViso2.cpp
|
|
odometry/OdometryDVO.cpp
|
|
odometry/OdometryOkvis.cpp
|
|
odometry/OdometryORBSLAM2.cpp
|
|
odometry/OdometryORBSLAM3.cpp
|
|
odometry/OdometryLOAM.cpp
|
|
odometry/OdometryFLOAM.cpp
|
|
odometry/OdometryLIOSAM.cpp
|
|
odometry/OdometryMSCKF.cpp
|
|
odometry/OdometryVINSFusion.cpp
|
|
odometry/OdometryOpenVINS.cpp
|
|
odometry/OdometryOpen3D.cpp
|
|
odometry/OdometryCuVSLAM.cpp
|
|
|
|
IMU.cpp
|
|
IMUThread.cpp
|
|
IMUFilter.cpp
|
|
imufilter/ComplementaryFilter.cpp
|
|
|
|
Stereo.cpp
|
|
StereoDense.cpp
|
|
StereoCameraModel.cpp
|
|
stereo/StereoBM.cpp
|
|
stereo/StereoSGBM.cpp
|
|
|
|
GlobalMap.cpp
|
|
LocalGridMaker.cpp
|
|
LocalGrid.cpp
|
|
global_map/OccupancyGrid.cpp
|
|
global_map/CloudMap.cpp
|
|
|
|
MarkerDetector.cpp
|
|
|
|
GlobalDescriptorExtractor.cpp
|
|
|
|
GainCompensator.cpp
|
|
|
|
rtflann/ext/lz4.c
|
|
rtflann/ext/lz4hc.c
|
|
FlannIndex.cpp
|
|
nanoflann/NanoFlannIndex.cpp
|
|
|
|
#clams stuff
|
|
clams/discrete_depth_distortion_model_helpers.cpp
|
|
clams/discrete_depth_distortion_model.cpp
|
|
clams/frame_projector.cpp
|
|
clams/slam_calibrator.cpp
|
|
|
|
opencv/ORBextractor.cc
|
|
opencv/solvepnp.cpp
|
|
opencv/five-point.cpp
|
|
)
|
|
|
|
IF(PCL_VERSION VERSION_GREATER_EQUAL "1.8")
|
|
SET(SRC_FILES
|
|
${SRC_FILES}
|
|
lidar/LidarVLP16.cpp
|
|
)
|
|
ENDIF(PCL_VERSION VERSION_GREATER_EQUAL "1.8")
|
|
|
|
IF(OpenCV_VERSION_MAJOR EQUAL 2)
|
|
SET(SRC_FILES
|
|
${SRC_FILES}
|
|
opencv/Orb.cpp
|
|
)
|
|
ENDIF(OpenCV_VERSION_MAJOR EQUAL 2)
|
|
|
|
# to get includes in visual studio
|
|
IF(MSVC)
|
|
FILE(GLOB HEADERS
|
|
../include/${PROJECT_PREFIX}/core/*.h
|
|
)
|
|
SET(SRC_FILES ${SRC_FILES} ${HEADERS})
|
|
ENDIF(MSVC)
|
|
|
|
SET(INCLUDE_DIRS
|
|
${ZLIB_INCLUDE_DIRS}
|
|
)
|
|
|
|
SET(PUBLIC_INCLUDE_DIRS
|
|
${OpenCV_INCLUDE_DIRS}
|
|
${PCL_INCLUDE_DIRS}
|
|
)
|
|
|
|
SET(LIBRARIES
|
|
${ZLIB_LIBRARIES}
|
|
)
|
|
|
|
# Issue that qhull dependency uses optimized and debug keywords,
|
|
# which are converted to \$<\$<NOT:\$<CONFIG:DEBUG>> and \$<\$<CONFIG:DEBUG>
|
|
# in RTABMap_coreTargets.cmake (not sure why?!).
|
|
list(REMOVE_ITEM PCL_LIBRARIES "debug" "optimized")
|
|
SET(PUBLIC_LIBRARIES
|
|
${OpenCV_LIBS}
|
|
${PCL_LIBRARIES}
|
|
)
|
|
|
|
IF(SQLite3_FOUND)
|
|
SET(INCLUDE_DIRS
|
|
${INCLUDE_DIRS}
|
|
${SQLite3_INCLUDE_DIRS}
|
|
)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
${SQLite3_LIBRARIES}
|
|
)
|
|
ELSE()
|
|
SET(SRC_FILES
|
|
${SRC_FILES}
|
|
sqlite3/sqlite3.c
|
|
)
|
|
SET(INCLUDE_DIRS
|
|
${CMAKE_CURRENT_SOURCE_DIR}/sqlite3
|
|
${INCLUDE_DIRS}
|
|
)
|
|
ENDIF()
|
|
|
|
IF(TORCH_FOUND)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
${TORCH_LIBRARIES}
|
|
)
|
|
SET(SRC_FILES
|
|
${SRC_FILES}
|
|
superpoint_torch/SuperPoint.cc
|
|
)
|
|
SET(INCLUDE_DIRS
|
|
${TORCH_INCLUDE_DIRS}
|
|
${CMAKE_CURRENT_SOURCE_DIR}/superpoint_torch
|
|
${INCLUDE_DIRS}
|
|
)
|
|
IF(WITH_PYTHON AND Python3_FOUND)
|
|
SET(SRC_FILES
|
|
${SRC_FILES}
|
|
superpoint_rpautrat/SuperpointRpautrat.cpp
|
|
)
|
|
SET(INCLUDE_DIRS
|
|
${CMAKE_CURRENT_SOURCE_DIR}/superpoint_rpautrat
|
|
${INCLUDE_DIRS}
|
|
)
|
|
ENDIF(WITH_PYTHON AND Python3_FOUND)
|
|
ENDIF(TORCH_FOUND)
|
|
|
|
IF(WITH_PYTHON AND Python3_FOUND)
|
|
SET(PUBLIC_LIBRARIES
|
|
${PUBLIC_LIBRARIES}
|
|
Python3::Python
|
|
Python3::NumPy
|
|
)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
pybind11::embed
|
|
)
|
|
SET(SRC_FILES
|
|
${SRC_FILES}
|
|
python/PythonInterface.cpp
|
|
python/PyMatcher.cpp
|
|
python/PyDetector.cpp
|
|
python/PyDescriptor.cpp
|
|
)
|
|
SET(INCLUDE_DIRS
|
|
${TORCH_INCLUDE_DIRS}
|
|
${CMAKE_CURRENT_SOURCE_DIR}/python
|
|
${INCLUDE_DIRS}
|
|
)
|
|
ENDIF(WITH_PYTHON AND Python3_FOUND)
|
|
|
|
|
|
|
|
IF(Freenect_FOUND)
|
|
IF(Freenect_DASH_INCLUDES)
|
|
ADD_DEFINITIONS("-DFREENECT_DASH_INCLUDES")
|
|
ENDIF(Freenect_DASH_INCLUDES)
|
|
SET(INCLUDE_DIRS
|
|
${INCLUDE_DIRS}
|
|
${Freenect_INCLUDE_DIRS}
|
|
)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
${Freenect_LIBRARIES}
|
|
)
|
|
ENDIF(Freenect_FOUND)
|
|
|
|
IF(OpenNI2_FOUND)
|
|
SET(INCLUDE_DIRS
|
|
${INCLUDE_DIRS}
|
|
${OpenNI2_INCLUDE_DIRS}
|
|
)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
${OpenNI2_LIBRARIES}
|
|
)
|
|
ENDIF(OpenNI2_FOUND)
|
|
|
|
IF(freenect2_FOUND)
|
|
SET(INCLUDE_DIRS
|
|
${INCLUDE_DIRS}
|
|
${freenect2_INCLUDE_DIRS}
|
|
)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
${freenect2_LIBRARIES}
|
|
)
|
|
ENDIF(freenect2_FOUND)
|
|
|
|
IF(KinectSDK2_FOUND)
|
|
SET(INCLUDE_DIRS
|
|
${INCLUDE_DIRS}
|
|
${KinectSDK2_INCLUDE_DIRS}
|
|
)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
${KinectSDK2_LIBRARIES}
|
|
)
|
|
ENDIF(KinectSDK2_FOUND)
|
|
|
|
IF(k4a_FOUND)
|
|
SET(PUBLIC_INCLUDE_DIRS
|
|
${PUBLIC_INCLUDE_DIRS}
|
|
${k4a_INCLUDE_DIRS}
|
|
)
|
|
IF(WIN32)
|
|
SET(PUBLIC_LIBRARIES
|
|
${PUBLIC_LIBRARIES}
|
|
${k4a_LIBRARIES}
|
|
)
|
|
ELSE()
|
|
SET(PUBLIC_LIBRARIES
|
|
${PUBLIC_LIBRARIES}
|
|
k4a::k4a
|
|
k4a::k4arecord
|
|
)
|
|
ENDIF()
|
|
ENDIF(k4a_FOUND)
|
|
|
|
IF(RealSense_FOUND)
|
|
SET(INCLUDE_DIRS
|
|
${INCLUDE_DIRS}
|
|
${RealSense_INCLUDE_DIRS}
|
|
)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
${RealSense_LIBRARIES}
|
|
)
|
|
ENDIF(RealSense_FOUND)
|
|
|
|
IF(realsense2_FOUND)
|
|
SET(PUBLIC_INCLUDE_DIRS
|
|
${PUBLIC_INCLUDE_DIRS}
|
|
${realsense2_INCLUDE_DIRS}
|
|
)
|
|
IF(WIN32)
|
|
SET(PUBLIC_LIBRARIES
|
|
${PUBLIC_LIBRARIES}
|
|
${RealSense2_LIBRARIES}
|
|
)
|
|
ELSEIF(APPLE)
|
|
SET(PUBLIC_LIBRARIES
|
|
${PUBLIC_LIBRARIES}
|
|
${realsense2_LIBRARIES}
|
|
)
|
|
ELSE()
|
|
SET(PUBLIC_LIBRARIES
|
|
${PUBLIC_LIBRARIES}
|
|
realsense2::realsense2 # target
|
|
)
|
|
ENDIF()
|
|
ENDIF(realsense2_FOUND)
|
|
|
|
IF(DC1394_FOUND)
|
|
SET(INCLUDE_DIRS
|
|
${INCLUDE_DIRS}
|
|
${DC1394_INCLUDE_DIRS}
|
|
)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
${DC1394_LIBRARIES}
|
|
)
|
|
ENDIF(DC1394_FOUND)
|
|
|
|
IF(FlyCapture2_FOUND)
|
|
SET(INCLUDE_DIRS
|
|
${INCLUDE_DIRS}
|
|
${FlyCapture2_INCLUDE_DIRS}
|
|
)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
${FlyCapture2_LIBRARIES}
|
|
)
|
|
ENDIF(FlyCapture2_FOUND)
|
|
|
|
IF(mynteye_FOUND)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
mynteye # target
|
|
)
|
|
ENDIF(mynteye_FOUND)
|
|
|
|
IF(depthai_FOUND)
|
|
SET(PUBLIC_LIBRARIES
|
|
${PUBLIC_LIBRARIES}
|
|
depthai::core
|
|
)
|
|
ENDIF(depthai_FOUND)
|
|
|
|
IF(xvsdk_FOUND)
|
|
SET(PUBLIC_LIBRARIES
|
|
${PUBLIC_LIBRARIES}
|
|
${xvsdk_LIBRARIES}
|
|
)
|
|
ENDIF(xvsdk_FOUND)
|
|
|
|
IF(OrbbecSDK_FOUND)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
ob::OrbbecSDK
|
|
)
|
|
ENDIF(OrbbecSDK_FOUND)
|
|
|
|
IF(TARGET OpenMP::OpenMP_CXX)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
OpenMP::OpenMP_CXX
|
|
)
|
|
ENDIF(TARGET OpenMP::OpenMP_CXX)
|
|
|
|
IF(WITH_TORO)
|
|
SET(SRC_FILES
|
|
${SRC_FILES}
|
|
optimizer/toro3d/posegraph3.cpp
|
|
optimizer/toro3d/treeoptimizer3_iteration.cpp
|
|
optimizer/toro3d/treeoptimizer3.cpp
|
|
|
|
optimizer/toro3d/posegraph2.cpp
|
|
optimizer/toro3d/treeoptimizer2.cpp
|
|
)
|
|
ENDIF(WITH_TORO)
|
|
|
|
IF(G2O_FOUND)
|
|
IF(g2o_FOUND)
|
|
SET(LIBRARIES ${LIBRARIES}
|
|
g2o::core
|
|
g2o::solver_eigen
|
|
g2o::solver_pcg
|
|
g2o::types_slam2d
|
|
g2o::types_slam3d
|
|
g2o::types_sba)
|
|
IF(TARGET g2o::solver_csparse)
|
|
SET(LIBRARIES ${LIBRARIES}
|
|
g2o::solver_csparse
|
|
g2o::csparse_extension)
|
|
ENDIF(TARGET g2o::solver_csparse)
|
|
IF(TARGET g2o::solver_cholmod)
|
|
SET(LIBRARIES ${LIBRARIES}
|
|
g2o::solver_cholmod)
|
|
ENDIF(TARGET g2o::solver_cholmod)
|
|
ELSE()
|
|
SET(INCLUDE_DIRS
|
|
${INCLUDE_DIRS}
|
|
${G2O_INCLUDE_DIRS}
|
|
)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
${G2O_LIBRARIES}
|
|
)
|
|
ENDIF()
|
|
IF(WITH_VERTIGO)
|
|
SET(SRC_FILES ${SRC_FILES}
|
|
optimizer/vertigo/g2o/edge_se2Switchable.cpp
|
|
optimizer/vertigo/g2o/edge_se3Switchable.cpp
|
|
optimizer/vertigo/g2o/edge_switchPrior.cpp
|
|
optimizer/vertigo/g2o/types_g2o_robust.cpp
|
|
optimizer/vertigo/g2o/vertex_switchLinear.cpp
|
|
)
|
|
ENDIF(WITH_VERTIGO)
|
|
ENDIF(G2O_FOUND)
|
|
|
|
IF(cvsba_FOUND)
|
|
SET(INCLUDE_DIRS
|
|
${INCLUDE_DIRS}
|
|
${cvsba_INCLUDE_DIRS}
|
|
)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
${cvsba_LIBS}
|
|
)
|
|
ENDIF(cvsba_FOUND)
|
|
|
|
IF(CERES_FOUND)
|
|
SET(INCLUDE_DIRS
|
|
${INCLUDE_DIRS}
|
|
${CERES_INCLUDE_DIRS}
|
|
)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
${CERES_LIBRARIES}
|
|
)
|
|
ENDIF(CERES_FOUND)
|
|
|
|
IF(MRPT_FOUND)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
${MRPT_LIBRARIES}
|
|
)
|
|
ENDIF(MRPT_FOUND)
|
|
|
|
IF(libpointmatcher_FOUND)
|
|
SET(INCLUDE_DIRS
|
|
${INCLUDE_DIRS}
|
|
${libpointmatcher_INCLUDE_DIRS}
|
|
)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
${libpointmatcher_LIBRARIES}
|
|
)
|
|
ENDIF(libpointmatcher_FOUND)
|
|
|
|
IF(CCCoreLib_FOUND)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
CCCoreLib::CCCoreLib
|
|
)
|
|
ENDIF(CCCoreLib_FOUND)
|
|
|
|
IF(Open3D_FOUND)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
Open3D::Open3D
|
|
)
|
|
ENDIF(Open3D_FOUND)
|
|
|
|
IF(FastCV_FOUND)
|
|
SET(INCLUDE_DIRS
|
|
${INCLUDE_DIRS}
|
|
${FastCV_INCLUDE_DIRS}
|
|
)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
${FastCV_LIBRARIES}
|
|
)
|
|
ENDIF(FastCV_FOUND)
|
|
|
|
IF(apriltag_FOUND)
|
|
SET(LIBRARIES
|
|
apriltag::apriltag
|
|
${LIBRARIES}
|
|
)
|
|
ENDIF(apriltag_FOUND)
|
|
|
|
IF(opengv_FOUND)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
opengv
|
|
)
|
|
ENDIF(opengv_FOUND)
|
|
|
|
IF(PDAL_FOUND)
|
|
SET(INCLUDE_DIRS
|
|
${INCLUDE_DIRS}
|
|
${PDAL_INCLUDE_DIRS}
|
|
)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
${PDAL_LIBRARIES}
|
|
)
|
|
SET(SRC_FILES
|
|
${SRC_FILES}
|
|
PDALWriter.cpp
|
|
)
|
|
IF(PDAL_VERSION VERSION_LESS "1.7")
|
|
add_definitions("-DRTABMAP_PDAL_16")
|
|
ENDIF(PDAL_VERSION VERSION_LESS "1.7")
|
|
ENDIF(PDAL_FOUND)
|
|
|
|
IF(libLAS_FOUND)
|
|
SET(INCLUDE_DIRS
|
|
${INCLUDE_DIRS}
|
|
${libLAS_INCLUDE_DIRS}
|
|
)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
${libLAS_LIBRARIES}
|
|
)
|
|
SET(SRC_FILES
|
|
${SRC_FILES}
|
|
LASWriter.cpp
|
|
)
|
|
ENDIF(libLAS_FOUND)
|
|
|
|
|
|
IF(CudaSift_FOUND)
|
|
#target
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
cudasift
|
|
)
|
|
ENDIF(CudaSift_FOUND)
|
|
|
|
|
|
IF(loam_velodyne_FOUND)
|
|
SET(INCLUDE_DIRS
|
|
${INCLUDE_DIRS}
|
|
${loam_velodyne_INCLUDE_DIRS}
|
|
)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
${loam_velodyne_LIBRARIES}
|
|
)
|
|
ENDIF(loam_velodyne_FOUND)
|
|
|
|
IF(floam_FOUND)
|
|
SET(INCLUDE_DIRS
|
|
${INCLUDE_DIRS}
|
|
${floam_INCLUDE_DIRS}
|
|
)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
${floam_LIBRARIES}
|
|
)
|
|
ENDIF(floam_FOUND)
|
|
|
|
IF(lio_sam_FOUND)
|
|
SET(INCLUDE_DIRS
|
|
${INCLUDE_DIRS}
|
|
${lio_sam_INCLUDE_DIRS}
|
|
)
|
|
link_directories(${lio_sam_LIBRARY_DIRS})
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
lio_sam_core
|
|
)
|
|
ENDIF(lio_sam_FOUND)
|
|
|
|
IF(ZED_FOUND)
|
|
SET(INCLUDE_DIRS
|
|
${INCLUDE_DIRS}
|
|
${ZED_INCLUDE_DIRS}
|
|
)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
${ZED_LIBRARIES}
|
|
)
|
|
IF(CUDA_FOUND)
|
|
SET(INCLUDE_DIRS
|
|
${INCLUDE_DIRS}
|
|
${CUDA_INCLUDE_DIRS}
|
|
)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
${CUDA_LIBRARIES}
|
|
)
|
|
ENDIF(CUDA_FOUND)
|
|
ENDIF(ZED_FOUND)
|
|
|
|
IF(ZEDOC_FOUND)
|
|
SET(INCLUDE_DIRS
|
|
${INCLUDE_DIRS}
|
|
${ZEDOC_INCLUDE_DIRS}
|
|
${HIDAPI_INCLUDE_DIRS}
|
|
)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
${ZEDOC_LIBRARIES}
|
|
${HIDAPI_LIBRARIES}
|
|
)
|
|
ENDIF(ZEDOC_FOUND)
|
|
|
|
IF(octomap_FOUND)
|
|
IF(TARGET octomap)
|
|
SET(PUBLIC_LIBRARIES
|
|
${PUBLIC_LIBRARIES}
|
|
octomap
|
|
)
|
|
ELSE()
|
|
SET(PUBLIC_INCLUDE_DIRS
|
|
${PUBLIC_INCLUDE_DIRS}
|
|
${OCTOMAP_INCLUDE_DIRS}
|
|
)
|
|
SET(PUBLIC_LIBRARIES
|
|
${PUBLIC_LIBRARIES}
|
|
${OCTOMAP_LIBRARIES}
|
|
)
|
|
ENDIF()
|
|
SET(SRC_FILES
|
|
${SRC_FILES}
|
|
global_map/OctoMap.cpp
|
|
)
|
|
ENDIF(octomap_FOUND)
|
|
|
|
IF(grid_map_core_FOUND)
|
|
IF(TARGET grid_map_core::grid_map_core)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
grid_map_core::grid_map_core
|
|
)
|
|
ELSE()
|
|
SET(INCLUDE_DIRS
|
|
${INCLUDE_DIRS}
|
|
${grid_map_core_INCLUDE_DIRS}
|
|
)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
${grid_map_core_LIBRARIES}
|
|
)
|
|
ENDIF()
|
|
SET(SRC_FILES
|
|
${SRC_FILES}
|
|
global_map/GridMap.cpp
|
|
)
|
|
ENDIF(grid_map_core_FOUND)
|
|
|
|
IF(AliceVision_FOUND)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
aliceVision_mesh
|
|
aliceVision_sfmDataIO)
|
|
ENDIF(AliceVision_FOUND)
|
|
|
|
IF(libfovis_FOUND)
|
|
SET(INCLUDE_DIRS
|
|
${INCLUDE_DIRS}
|
|
${libfovis_INCLUDE_DIRS}
|
|
)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
${libfovis_LIBRARIES}
|
|
)
|
|
ENDIF(libfovis_FOUND)
|
|
|
|
IF(libviso2_FOUND)
|
|
SET(INCLUDE_DIRS
|
|
${INCLUDE_DIRS}
|
|
${libviso2_INCLUDE_DIRS}
|
|
)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
${libviso2_LIBRARIES}
|
|
)
|
|
ENDIF(libviso2_FOUND)
|
|
|
|
IF(dvo_core_FOUND)
|
|
SET(INCLUDE_DIRS
|
|
${INCLUDE_DIRS}
|
|
${dvo_core_INCLUDE_DIRS}
|
|
)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
${dvo_core_LIBRARIES}
|
|
)
|
|
ENDIF(dvo_core_FOUND)
|
|
|
|
IF(okvis_FOUND)
|
|
SET(INCLUDE_DIRS
|
|
${OKVIS_INCLUDE_DIRS}
|
|
${BRISK_INCLUDE_DIRS}
|
|
${OPENGV_INCLUDE_DIRS}
|
|
${CERES_INCLUDE_DIRS}
|
|
${INCLUDE_DIRS}
|
|
)
|
|
SET(LIBRARIES
|
|
${OKVIS_LIBRARIES}
|
|
${BRISK_LIBRARIES}
|
|
${OPENGV_LIBRARIES}
|
|
${CERES_LIBRARIES}
|
|
${LIBRARIES}
|
|
)
|
|
ENDIF(okvis_FOUND)
|
|
|
|
IF(msckf_vio_FOUND)
|
|
SET(INCLUDE_DIRS
|
|
${msckf_vio_INCLUDE_DIRS}
|
|
${INCLUDE_DIRS}
|
|
)
|
|
SET(LIBRARIES
|
|
${msckf_vio_LIBRARIES}
|
|
${LIBRARIES}
|
|
)
|
|
ENDIF(msckf_vio_FOUND)
|
|
|
|
IF(vins_FOUND)
|
|
SET(INCLUDE_DIRS
|
|
${vins_INCLUDE_DIRS}
|
|
${INCLUDE_DIRS}
|
|
)
|
|
SET(LIBRARIES
|
|
${vins_LIBRARIES}
|
|
${LIBRARIES}
|
|
)
|
|
ENDIF(vins_FOUND)
|
|
|
|
IF(OpenVINS_FOUND)
|
|
SET(INCLUDE_DIRS
|
|
${OpenVINS_INCLUDE_DIRS}
|
|
${INCLUDE_DIRS}
|
|
)
|
|
SET(LIBRARIES
|
|
${OpenVINS_LIBRARIES}
|
|
${LIBRARIES}
|
|
)
|
|
ENDIF(OpenVINS_FOUND)
|
|
|
|
IF(ORB_SLAM_FOUND)
|
|
SET(INCLUDE_DIRS
|
|
${ORB_SLAM_INCLUDE_DIRS} #before so that g2o includes are taken from ORB_SLAM directory before the official g2o one
|
|
${INCLUDE_DIRS}
|
|
)
|
|
SET(LIBRARIES
|
|
${ORB_SLAM_LIBRARIES}
|
|
${LIBRARIES}
|
|
)
|
|
ENDIF(ORB_SLAM_FOUND)
|
|
|
|
IF(CUVSLAM_FOUND)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
cuvslam::cuvslam
|
|
)
|
|
ENDIF(CUVSLAM_FOUND)
|
|
|
|
IF(GTSAM_FOUND)
|
|
SET(LIBRARIES
|
|
${LIBRARIES}
|
|
gtsam
|
|
)
|
|
ENDIF(GTSAM_FOUND)
|
|
|
|
IF(WITH_MADGWICK)
|
|
SET(SRC_FILES
|
|
${SRC_FILES}
|
|
imufilter/MadgwickFilter.cpp
|
|
)
|
|
ENDIF(WITH_MADGWICK)
|
|
|
|
####################################
|
|
# Generate resources files
|
|
####################################
|
|
CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/resources/DatabaseSchema.sql.in ${CMAKE_CURRENT_SOURCE_DIR}/resources/DatabaseSchema.sql)
|
|
|
|
SET(RESOURCES
|
|
${CMAKE_CURRENT_SOURCE_DIR}/resources/DatabaseSchema.sql
|
|
${CMAKE_CURRENT_SOURCE_DIR}/resources/backward_compatibility/DatabaseSchema_0_22_0.sql
|
|
${CMAKE_CURRENT_SOURCE_DIR}/resources/backward_compatibility/DatabaseSchema_0_20_0.sql
|
|
${CMAKE_CURRENT_SOURCE_DIR}/resources/backward_compatibility/DatabaseSchema_0_18_3.sql
|
|
${CMAKE_CURRENT_SOURCE_DIR}/resources/backward_compatibility/DatabaseSchema_0_18_0.sql
|
|
${CMAKE_CURRENT_SOURCE_DIR}/resources/backward_compatibility/DatabaseSchema_0_17_0.sql
|
|
${CMAKE_CURRENT_SOURCE_DIR}/resources/backward_compatibility/DatabaseSchema_0_16_2.sql
|
|
${CMAKE_CURRENT_SOURCE_DIR}/resources/backward_compatibility/DatabaseSchema_0_16_1.sql
|
|
${CMAKE_CURRENT_SOURCE_DIR}/resources/backward_compatibility/DatabaseSchema_0_16_0.sql
|
|
)
|
|
|
|
IF(TORCH_FOUND AND WITH_PYTHON AND Python3_FOUND)
|
|
SET(RESOURCES
|
|
${RESOURCES}
|
|
${CMAKE_CURRENT_SOURCE_DIR}/superpoint_rpautrat/superpoint_to_torchscript.py
|
|
)
|
|
ENDIF()
|
|
|
|
foreach(arg ${RESOURCES})
|
|
get_filename_component(filename ${arg} NAME)
|
|
string(REPLACE "." "_" output ${filename})
|
|
set(RESOURCES_HEADERS "${RESOURCES_HEADERS}" "${CMAKE_CURRENT_BINARY_DIR}/${output}.h")
|
|
set_property(SOURCE "${CMAKE_CURRENT_BINARY_DIR}/${output}.h" PROPERTY SKIP_AUTOGEN ON)
|
|
endforeach(arg ${RESOURCES})
|
|
|
|
#MESSAGE(STATUS "RESOURCES = ${RESOURCES}")
|
|
#MESSAGE(STATUS "RESOURCES_HEADERS = ${RESOURCES_HEADERS}")
|
|
|
|
ADD_CUSTOM_COMMAND(
|
|
OUTPUT ${RESOURCES_HEADERS}
|
|
COMMAND res_tool -n rtabmap -p ${CMAKE_CURRENT_BINARY_DIR} ${RESOURCES}
|
|
COMMENT "[Creating resources]"
|
|
DEPENDS ${RESOURCES}
|
|
)
|
|
|
|
####################################
|
|
# Generate resources files END
|
|
####################################
|
|
|
|
add_definitions(${PCL_DEFINITIONS})
|
|
|
|
# Add binary that is built from the source file "main.cpp".
|
|
# The extension is automatically found.
|
|
# rtflann's config.h is generated, as it is upstream, so that the
|
|
# FLANN_KDTREE_MEM_OPT option travels in a header instead of a compile
|
|
# definition: toggling it then recompiles the sources including rtflann rather
|
|
# than every object file of the library (see the header for the details).
|
|
configure_file(
|
|
${CMAKE_CURRENT_SOURCE_DIR}/rtflann/config.h.in
|
|
${CMAKE_CURRENT_BINARY_DIR}/rtflann/config.h)
|
|
|
|
ADD_LIBRARY(rtabmap_core ${SRC_FILES} ${RESOURCES_HEADERS})
|
|
ADD_LIBRARY(rtabmap::core ALIAS rtabmap_core)
|
|
|
|
generate_export_header(rtabmap_core
|
|
DEPRECATED_MACRO_NAME RTABMAP_DEPRECATED)
|
|
|
|
target_include_directories(rtabmap_core PUBLIC
|
|
"$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR};${CMAKE_CURRENT_SOURCE_DIR}/../include;${CMAKE_CURRENT_BINARY_DIR};${CMAKE_CURRENT_BINARY_DIR}/include>"
|
|
"$<INSTALL_INTERFACE:${INSTALL_INCLUDE_DIR}>")
|
|
|
|
target_include_directories(rtabmap_core SYSTEM PUBLIC
|
|
"$<BUILD_INTERFACE:${PUBLIC_INCLUDE_DIRS};${INCLUDE_DIRS}>"
|
|
"$<INSTALL_INTERFACE:${PUBLIC_INCLUDE_DIRS}>")
|
|
|
|
# GCC 12 false positives from PCL/Eigen template instantiations (SSE codepath
|
|
# unaligned-loads 16 bytes from a 3-element Eigen vector). Eigen knows the
|
|
# over-read is safe; GCC 12 doesn't. Fixed in GCC 13. PCL itself doesn't
|
|
# trigger this in its own build because the offending code is in templated
|
|
# headers and only fires in downstream TUs. Same scope/approach as
|
|
# pybind11 PR #5355.
|
|
if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU"
|
|
AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 12
|
|
AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 13)
|
|
target_compile_options(rtabmap_core PRIVATE -Wno-array-bounds -Wno-stringop-overread)
|
|
|
|
# GCC 12 -Wuse-after-free false positive on the vendored TORO library's
|
|
# reference-counted DMatrix destructor: when multiple ~DMatrix<double>()
|
|
# inline at the same closing brace, GCC's cross-call flow analysis can't
|
|
# prove the freed and re-read 'shares' pointers belong to different
|
|
# objects. Scope to the TORO sources only.
|
|
if(WITH_TORO)
|
|
set_source_files_properties(
|
|
optimizer/toro3d/posegraph3.cpp
|
|
optimizer/toro3d/treeoptimizer3_iteration.cpp
|
|
optimizer/toro3d/treeoptimizer3.cpp
|
|
optimizer/toro3d/posegraph2.cpp
|
|
optimizer/toro3d/treeoptimizer2.cpp
|
|
PROPERTIES COMPILE_OPTIONS "-Wno-use-after-free")
|
|
endif()
|
|
|
|
# GCC 12 -Wmaybe-uninitialized false positive: Eigen's SSE codepath
|
|
# _mm_loadu_pd's an uninitialized-by-design Eigen::Matrix<double,3,3>
|
|
# inside g2o::SBACam. GCC follows the SIMD load through and flags it as
|
|
# potentially uninitialized; Eigen relies on the caller to assign before
|
|
# reading. Only OptimizerG2O.cpp instantiates SBACam.
|
|
if(G2O_FOUND)
|
|
set_source_files_properties(
|
|
optimizer/OptimizerG2O.cpp
|
|
PROPERTIES COMPILE_OPTIONS "-Wno-maybe-uninitialized")
|
|
endif()
|
|
endif()
|
|
|
|
TARGET_LINK_LIBRARIES(rtabmap_core
|
|
PUBLIC
|
|
rtabmap_utilite
|
|
${PUBLIC_LIBRARIES}
|
|
PRIVATE
|
|
${LIBRARIES})
|
|
|
|
SET_TARGET_PROPERTIES(
|
|
rtabmap_core
|
|
PROPERTIES
|
|
VERSION ${RTABMAP_VERSION}
|
|
SOVERSION ${RTABMAP_MAJOR_VERSION}.${RTABMAP_MINOR_VERSION}
|
|
EXPORT_NAME "core"
|
|
)
|
|
|
|
INSTALL(TARGETS rtabmap_core EXPORT rtabmap_coreTargets
|
|
RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}" COMPONENT runtime
|
|
LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}" COMPONENT devel
|
|
ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}" COMPONENT devel)
|
|
|
|
configure_file(
|
|
${CMAKE_CURRENT_BINARY_DIR}/rtabmap_core_export.h
|
|
${CMAKE_CURRENT_BINARY_DIR}/include/${PROJECT_PREFIX}/core/rtabmap_core_export.h
|
|
COPYONLY)
|
|
|
|
install(
|
|
DIRECTORY
|
|
${CMAKE_CURRENT_SOURCE_DIR}/../include/${PROJECT_PREFIX}
|
|
${CMAKE_CURRENT_BINARY_DIR}/include/${PROJECT_PREFIX}
|
|
DESTINATION
|
|
${INSTALL_INCLUDE_DIR}
|
|
COMPONENT
|
|
devel
|
|
FILES_MATCHING PATTERN "*.h" PATTERN "*.hpp"
|
|
)
|
|
|
|
export(EXPORT rtabmap_coreTargets
|
|
FILE "${CMAKE_CURRENT_BINARY_DIR}/../../${PROJECT_NAME}_coreTargets.cmake"
|
|
NAMESPACE rtabmap::
|
|
)
|
|
|
|
install(EXPORT rtabmap_coreTargets
|
|
FILE
|
|
${PROJECT_NAME}_coreTargets.cmake
|
|
DESTINATION
|
|
${INSTALL_CMAKE_DIR}
|
|
NAMESPACE rtabmap::
|
|
COMPONENT
|
|
devel
|
|
)
|
|
|