Adding doc and tests (#1492)

* added doc and tests for util2d.h

* updated cmake-ros ci

* Added util3d.h doc and tests

* util3d_transforms.h: Added doc and tests

* util3d_filtering.h: started doc and test

* util3d_filtering.h: more tests and doc

* Added more doc/tests

* finished util3d_filtering doc and tests

* added test for util2d::depthBleedingFiltering

* Added util3d_registration tests

* Added util3d_features.h doc/tests

* added doc/tests for util3d_correspondences.h

* added doc/gtest for util3d_mapping.h (missing hpp functions)

* finished testing util3d_mapping.hpp

* Added util3d_motion_estimation.h tests (2D->3D done)

* finished util3d_motion_estimation.h tests

* minimal util3d_surface.h

* Added Transform and VisualWord tests

* Added doc for CameraModel and StereoCameraModel

* Added more logs in ros ci

* Passing tests on fical

* improved all devcontainer

* added devcontainer kilted, fixed source setup.bash, removed ldconfig in ros-cmake workflow

* cleanup

* source ros

* Added utilite tests

* Added testing to appveyor, github actions cancellable on re-commit on same branch

* appveyor testing without all targets

* appveyor: specifying ALL_BUILD target

* Fixed Util2dTest.NMSImageBoundsRespected test

* Fixing PCL Indices error on old pcl

* Added VWDictionary tests and doc. Fixed LSH not working (fix from https://github.com/flann-lib/flann/pull/472

* fixing some appveyor CI errors, added test to check dictionary serialization against all type

* Added StereoDense, StereoBM and StereoSGBM doc and tests

* Added Stereo tests

* Added CameraModel and StereoCameraModel tests

* Added doc and test for Statistics

* Added doc/tests for Signature

* Added doc/test for SensorEvent, added doc for SensorCaptureInfo

* Added doc to SensorData

* Added SensorData tests

* Added SensorCapture and SensorCaptureThread doc and tests

* fixed sensordata test

* updated SSC test and doc

* Added doc and tests for BayesFilter class

* Enabled testing on mac, updated windows testing like on linux

* added test_link

* fixed unresolved on windows

* fixed ThreadHandle error on macos ci

* Added GPS and GeodeticCoords tests

* Added tests for compression

* Added Odometry tests (base class only)

* Added DBDriver tests

* Added coverage report

* uniformized test names

* fixing concurancy and coverage ci

* dont built tools, examples and app for coverage build

* fixed report tool rebuilt without qt compilation error

* updated coverage option

* updated coverage config

* added doc CI job

* fixing windows and mac ci errors

* Added DBDriverSqlite3 tests

* Added IMU tests

* Added Graph tests

* fixing flaky macos test

* Added IMUThread and IMUFilter tests

* Added Landmarks tests

* Added LASWriter tests

* fixing seed flaky test

* fixing flaky macos timing tests

* Added LocalGrid tests

* Added LocalGridMaker tests

* fixing ci errors

* Added GlobalMap tests

* Added doc for EnvSensor

* Added Features2D tests

* Added Registration tests

* Added RegistrationVis tests

* Added doc for Rtabmap and Memory classes

* Added Memory and Rtabmap tests

* making some tests less flaky

* lcov 1.14 support

* updated compatible tool arguments

* Added integration tests (RGB-D, Stereo, Lidar2d, Lidar3d)

* More octomap checks

* Refactored how/when python interpretor is created to simplify library usage

* Added python tests

* fixed some flaky tests

* suppressed some third party related warnings

* fixed ceres tests

* more flaky fixes

* Fixing tests without libpointmatcher

* Added RANSAC rejection filter to PCL ICP

* fixing multi platform flakiness

* Added test to detect regression

* Fixing windows pcl link error

* fixed some macos flakiness

* bigger 2D2D registration error on opencv 4.6.0

* flakiness

* fixing flaky tests on windows and mac

* flaky thread test on slow mac VM

* windows slow test

* fixing more ci erros

* fxing temp dir on windows

* Added Optimizer tests and discovered some bugs (fixed)

* fixing flaky tests in mac and windows

* Added Optimizer doc

* Added GTSAM BA, updated Ceres to use g2o ba parameters. Renamed g2o's ba related parameters to Optimizer group and used by both gtsam and ceres.

* fixing build without gtsam

* fixing home dir

* fixing python ci isssues

* Added multicam ba tests

* Added Ceres multicam BA support

* Aligned BundleAdjustment parameters with Optimizer/Strategy to avoid confusion in the code

* Added BA integration test

* Added robust graph optimization integration test

* Added loop3it test

* Added stereo20Hz test

* Added smartfactor gtsam

* Fixed bugged check and warn if python didn't return any descriptors

* Fixing gtsam version build issues

* fixing tilt on windows ci

* loosing ceres integration test for ci

* mac ci flakiness

* updating missing param in gui

* updating test bound for mac

* added appearance-based tests, set min gftt quality to quality level

* testing more stuff

* improving features2d tests

* ci flakiness

* fixing flaky ci

* ci fixes

* flaky fixes

* Added RegistrationIcp tests

* Added icp integration test with real-worl corridor like env

* intermediate nodes

* fixing enum

* Updated test to catch #1714

* Fixed 2d corridor failing on pcl

* flaky pnp test

* flaky brisk test

* Set rtabmap_integration test as long

* updating loop closure test

* flaky ci tests

* TEsting roundtrip g2o/toro save/load

* loosing test bound

* fixed cuda capable checks

* flaky tests

* Debugging test hanging

* more debugging stuff

* updating limit

* windows: disabled cuda on ci to avoid incompatible driver issue. Fixing a bad test mem allocation

* trying fixing cuda hanging issue

* fixing ci flakyness

* flaky tests

* Updated BOW flaky tests by checking min precision/recall instead of recall@100precision. Fixed signature test

* CameraModel::load() test initRectificationMap param

* test dbdriver load dictionary idsOnly

* Memory: test keepLinkedInDb param

* added dummyDictionary tests

* test intermediate nodes count

* Added MarkerDetector tests

* reverted breaking change of UMutex and USemaphore

* Features2d: fixed compiltion warnings with clang about override

* clang warnings

* fixing test build with pcl 1.8

* g2o and gtsam build errors on android

* opencv5 test fixes

* disabled testing for ios and android builds

* normalized endline characters for easier diff

* added LF CRLF rule

* bump 0.23.10. fixing doc version

* Publish rtabmap website doc from ci

* fixing MSCVC build error

* macos icp flaky test

* fixing ceres macos test bound

* ficing more flaky tests

* fixing opencv5 related test errors. Also fixed an actual bug in ENU_WGS84ToGeocentric_WGS84()

* added comment about mrpt change

* removed rosdoc2 (will add it for rtabmap_ros later)

* fixing website style

* updated download links

* locally deployable website with api

* sweep doxygen issues

* improved/revised doxygen main pages

* removed examples empty page

* Updated doxygen style

* more concise doxygen groups

* added api link on main readme

* fixing utilite test error

* fixing CommonFilteringGroundNormalsUp test

* updated precisionRecall test bounds for Freak and brief descriptors

* fixing scale check in ba tests

* disabled tests on windows cuda build (missing dlls amd runner cannot test cuda anyway)

* ceres: missing suitesparse dep in windows ci

* adjusting recall thr for fast/freak

* ficing more flaky tests

* fixing flaky tests

* disabled coverage in ros ci

* Enable integration tests for ros ci jobs

* loosing up some threshold for failing tests

* trigger cache

* fixing test data in ros ci. Updated flaky test for mac

* slaking some test limit

* Fixed rtabmap-detectMoreLoopClosures inverted output value

* loosing up sift recall on mac

* optimizer re-ordered distribution for reproducible results (mac g2o)

* macos dump test crash log

* combining all tests to save time on shared library reload. Also fixed Logs with missing arguments.

* Added ENABLE_FORMAT_ERRORS cmake option

* do test only one time

* fixed all format warnings

* format security android build errors

* less verbose tests

* updated ImuUThread test

* fixed a log

* Fixed libpointmatcher 2d normals eigen issue

* Fixing libpointmatcher conversion issues

* fixing libpointmatcher test on windows ci

* cleanup comments, relax some test thr

* disabled sequoia-intel ci build (too flaky, would need extensive testing directly on that machine)
This commit is contained in:
matlabbe
2026-08-06 13:32:20 -07:00
committed by GitHub
parent bcdb4b4546
commit ee49beaf4f
309 changed files with 67469 additions and 3070 deletions

View File

@@ -0,0 +1,447 @@
#include <gtest/gtest.h>
#include <rtabmap/core/SensorCapture.h>
#include <rtabmap/core/SensorData.h>
#include <rtabmap/core/SensorCaptureInfo.h>
#include <rtabmap/core/Transform.h>
#include <rtabmap/utilite/UTimer.h>
#include <opencv2/core.hpp>
using namespace rtabmap;
// Mock SensorCapture implementation for testing
class MockSensorCapture : public SensorCapture
{
public:
MockSensorCapture(float frameRate = 0, const Transform & localTransform = Transform::getIdentity()) :
SensorCapture(frameRate, localTransform),
initCalled_(false),
initResult_(true),
serial_("MOCK_SENSOR_001"),
odomProvided_(false),
captureCount_(0)
{
}
virtual ~MockSensorCapture() {}
virtual bool init(const std::string & calibrationFolder = ".", const std::string & cameraName = "")
{
initCalled_ = true;
calibrationFolder_ = calibrationFolder;
cameraName_ = cameraName;
return initResult_;
}
virtual std::string getSerial() const
{
return serial_;
}
virtual bool odomProvided() const
{
return odomProvided_;
}
virtual bool getPose(double stamp, Transform & pose, cv::Mat & covariance, double maxWaitTime = 0.06)
{
if (odomProvided_)
{
pose = Transform(1, 0, 0, 0, 0, 0, 1);
covariance = cv::Mat::eye(6, 6, CV_64FC1);
return true;
}
return false;
}
// Test helpers
void setInitResult(bool result) { initResult_ = result; }
void setSerial(const std::string & serial) { serial_ = serial; }
void setOdomProvided(bool provided) { odomProvided_ = true; }
bool wasInitCalled() const { return initCalled_; }
std::string getCalibrationFolder() const { return calibrationFolder_; }
std::string getCameraName() const { return cameraName_; }
int getCaptureCount() const { return captureCount_; }
protected:
virtual SensorData captureData(SensorCaptureInfo * info = 0)
{
++captureCount_;
cv::Mat image = cv::Mat::ones(480, 640, CV_8UC3) * 128;
SensorData data(image, getNextSeqID(), UTimer::now());
return data;
}
private:
bool initCalled_;
bool initResult_;
std::string serial_;
bool odomProvided_;
std::string calibrationFolder_;
std::string cameraName_;
int captureCount_;
};
// Constructor Tests
TEST(SensorCaptureTest, DefaultConstructor)
{
MockSensorCapture sensor;
EXPECT_EQ(sensor.getFrameRate(), 0.0f);
EXPECT_TRUE(sensor.getLocalTransform().isIdentity());
EXPECT_FALSE(sensor.wasInitCalled());
EXPECT_EQ(sensor.getSerial(), "MOCK_SENSOR_001");
EXPECT_FALSE(sensor.odomProvided());
}
TEST(SensorCaptureTest, ConstructorWithFrameRate)
{
float frameRate = 30.0f;
MockSensorCapture sensor(frameRate);
EXPECT_FLOAT_EQ(sensor.getFrameRate(), frameRate);
EXPECT_TRUE(sensor.getLocalTransform().isIdentity());
}
TEST(SensorCaptureTest, ConstructorWithLocalTransform)
{
Transform localTransform(1, 0, 0, 0, 0, 0, 1);
MockSensorCapture sensor(0, localTransform);
EXPECT_EQ(sensor.getLocalTransform(), localTransform);
}
TEST(SensorCaptureTest, ConstructorWithFrameRateAndTransform)
{
float frameRate = 15.0f;
Transform localTransform(0, 0, 1, 0, -1, 0, 0, 0, 0, -1, 0, 0);
MockSensorCapture sensor(frameRate, localTransform);
EXPECT_FLOAT_EQ(sensor.getFrameRate(), frameRate);
EXPECT_EQ(sensor.getLocalTransform(), localTransform);
}
// Init Tests
TEST(SensorCaptureTest, InitDefault)
{
MockSensorCapture sensor;
EXPECT_TRUE(sensor.init());
EXPECT_TRUE(sensor.wasInitCalled());
EXPECT_EQ(sensor.getCalibrationFolder(), ".");
EXPECT_EQ(sensor.getCameraName(), "");
}
TEST(SensorCaptureTest, InitWithCalibrationFolder)
{
MockSensorCapture sensor;
std::string folder = "/path/to/calibration";
EXPECT_TRUE(sensor.init(folder));
EXPECT_EQ(sensor.getCalibrationFolder(), folder);
EXPECT_EQ(sensor.getCameraName(), "");
}
TEST(SensorCaptureTest, InitWithCalibrationFolderAndCameraName)
{
MockSensorCapture sensor;
std::string folder = "/path/to/calibration";
std::string cameraName = "camera1";
EXPECT_TRUE(sensor.init(folder, cameraName));
EXPECT_EQ(sensor.getCalibrationFolder(), folder);
EXPECT_EQ(sensor.getCameraName(), cameraName);
}
TEST(SensorCaptureTest, InitFailure)
{
MockSensorCapture sensor;
sensor.setInitResult(false);
EXPECT_FALSE(sensor.init());
EXPECT_TRUE(sensor.wasInitCalled());
}
// Serial Tests
TEST(SensorCaptureTest, GetSerial)
{
MockSensorCapture sensor;
EXPECT_EQ(sensor.getSerial(), "MOCK_SENSOR_001");
sensor.setSerial("CUSTOM_SERIAL_123");
EXPECT_EQ(sensor.getSerial(), "CUSTOM_SERIAL_123");
}
// Frame Rate Tests
TEST(SensorCaptureTest, SetGetFrameRate)
{
MockSensorCapture sensor;
EXPECT_EQ(sensor.getFrameRate(), 0.0f);
sensor.setFrameRate(30.0f);
EXPECT_FLOAT_EQ(sensor.getFrameRate(), 30.0f);
sensor.setFrameRate(0.0f);
EXPECT_FLOAT_EQ(sensor.getFrameRate(), 0.0f);
sensor.setFrameRate(60.0f);
EXPECT_FLOAT_EQ(sensor.getFrameRate(), 60.0f);
}
// Local Transform Tests
TEST(SensorCaptureTest, SetGetLocalTransform)
{
MockSensorCapture sensor;
EXPECT_TRUE(sensor.getLocalTransform().isIdentity());
Transform transform(1, 0, 0, 0, 0, 0, 1);
sensor.setLocalTransform(transform);
EXPECT_EQ(sensor.getLocalTransform(), transform);
Transform transform2(0, 0, 1, 0, -1, 0, 0, 0, 0, -1, 0, 0);
sensor.setLocalTransform(transform2);
EXPECT_EQ(sensor.getLocalTransform(), transform2);
}
// Reset Timer Tests
TEST(SensorCaptureTest, ResetTimer)
{
MockSensorCapture sensor;
// Reset should not throw
EXPECT_NO_THROW(sensor.resetTimer());
// After reset, timer should be ready for frame rate control
sensor.setFrameRate(10.0f);
sensor.resetTimer();
// First capture should be fast (no throttling needed)
SensorData data = sensor.takeData();
EXPECT_TRUE(data.isValid());
}
// TakeData Tests
TEST(SensorCaptureTest, TakeDataBasic)
{
MockSensorCapture sensor;
SensorData data = sensor.takeData();
EXPECT_TRUE(data.isValid());
EXPECT_GT(data.id(), 0);
EXPECT_GT(data.stamp(), 0.0);
EXPECT_FALSE(data.imageRaw().empty());
EXPECT_EQ(sensor.getCaptureCount(), 1);
}
TEST(SensorCaptureTest, TakeDataWithInfo)
{
MockSensorCapture sensor;
SensorCaptureInfo info;
SensorData data = sensor.takeData(&info);
EXPECT_TRUE(data.isValid());
EXPECT_EQ(info.id, data.id());
EXPECT_DOUBLE_EQ(info.stamp, data.stamp());
EXPECT_GT(info.timeCapture, 0.0);
EXPECT_LE(info.timeCapture, 0.1); // Should be very fast for mock
}
TEST(SensorCaptureTest, TakeDataSequenceIDs)
{
MockSensorCapture sensor;
SensorData data1 = sensor.takeData();
SensorData data2 = sensor.takeData();
SensorData data3 = sensor.takeData();
EXPECT_EQ(data1.id() + 1, data2.id());
EXPECT_EQ(data2.id() + 1, data3.id());
EXPECT_EQ(sensor.getCaptureCount(), 3);
}
TEST(SensorCaptureTest, TakeDataNoFrameRateThrottling)
{
MockSensorCapture sensor;
sensor.setFrameRate(0.0f); // Unlimited
UTimer timer;
SensorData data1 = sensor.takeData();
SensorData data2 = sensor.takeData();
double elapsed = timer.ticks();
// Without throttling, captures should be very fast
EXPECT_LT(elapsed, 0.1);
EXPECT_TRUE(data1.isValid());
EXPECT_TRUE(data2.isValid());
}
TEST(SensorCaptureTest, TakeDataWithFrameRateThrottling)
{
MockSensorCapture sensor;
sensor.setFrameRate(10.0f); // 10 Hz = 100ms per frame
sensor.resetTimer();
UTimer timer;
SensorData data1 = sensor.takeData();
SensorData data2 = sensor.takeData();
double elapsed = timer.ticks();
// With 10 Hz throttling, two captures should wait ~100 ms each (~200 ms total).
EXPECT_GE(elapsed, 0.19);
EXPECT_LE(elapsed, 1.0); // allow scheduler jitter on loaded CI runners (e.g. macOS overshot 0.5 by ~3 ms)
EXPECT_TRUE(data1.isValid());
EXPECT_TRUE(data2.isValid());
}
// OdomProvided Tests
TEST(SensorCaptureTest, OdomProvidedDefault)
{
MockSensorCapture sensor;
EXPECT_FALSE(sensor.odomProvided());
}
TEST(SensorCaptureTest, OdomProvidedEnabled)
{
MockSensorCapture sensor;
sensor.setOdomProvided(true);
EXPECT_TRUE(sensor.odomProvided());
}
// GetPose Tests
TEST(SensorCaptureTest, GetPoseDefault)
{
MockSensorCapture sensor;
Transform pose;
cv::Mat covariance;
EXPECT_FALSE(sensor.getPose(0.0, pose, covariance));
}
TEST(SensorCaptureTest, GetPoseWithOdom)
{
MockSensorCapture sensor;
sensor.setOdomProvided(true);
Transform pose;
cv::Mat covariance;
EXPECT_TRUE(sensor.getPose(0.0, pose, covariance));
EXPECT_FALSE(pose.isNull());
EXPECT_FALSE(covariance.empty());
EXPECT_EQ(covariance.rows, 6);
EXPECT_EQ(covariance.cols, 6);
}
// Comprehensive Usage Test
TEST(SensorCaptureTest, ComprehensiveUsage)
{
// Create sensor with frame rate and transform
float frameRate = 20.0f;
Transform localTransform(0, 0, 1, 0, -1, 0, 0, 0, 0, -1, 0, 0);
MockSensorCapture sensor(frameRate, localTransform);
// Initialize
EXPECT_TRUE(sensor.init("/calib", "test_camera"));
EXPECT_EQ(sensor.getCalibrationFolder(), "/calib");
EXPECT_EQ(sensor.getCameraName(), "test_camera");
// Verify settings
EXPECT_FLOAT_EQ(sensor.getFrameRate(), frameRate);
EXPECT_EQ(sensor.getLocalTransform(), localTransform);
EXPECT_EQ(sensor.getSerial(), "MOCK_SENSOR_001");
// Change settings
sensor.setFrameRate(30.0f);
Transform newTransform = Transform::getIdentity();
sensor.setLocalTransform(newTransform);
sensor.setSerial("NEW_SERIAL");
EXPECT_FLOAT_EQ(sensor.getFrameRate(), 30.0f);
EXPECT_EQ(sensor.getLocalTransform(), newTransform);
EXPECT_EQ(sensor.getSerial(), "NEW_SERIAL");
// Capture data
sensor.resetTimer();
SensorCaptureInfo info;
SensorData data = sensor.takeData(&info);
EXPECT_TRUE(data.isValid());
EXPECT_EQ(info.id, data.id());
EXPECT_DOUBLE_EQ(info.stamp, data.stamp());
EXPECT_GT(info.timeCapture, 0.0);
EXPECT_EQ(sensor.getCaptureCount(), 1);
}
// Edge Cases
TEST(SensorCaptureTest, TakeDataMultipleCalls)
{
MockSensorCapture sensor;
for (int i = 0; i < 10; ++i)
{
SensorData data = sensor.takeData();
EXPECT_TRUE(data.isValid());
}
EXPECT_EQ(sensor.getCaptureCount(), 10);
}
TEST(SensorCaptureTest, TakeDataWithNullInfo)
{
MockSensorCapture sensor;
// Should not crash with null info
SensorData data = sensor.takeData(nullptr);
EXPECT_TRUE(data.isValid());
}
TEST(SensorCaptureTest, HighFrameRate)
{
MockSensorCapture sensor;
sensor.setFrameRate(1000.0f); // Very high frame rate
sensor.resetTimer();
// Should handle high frame rate gracefully
UTimer timer;
SensorData data = sensor.takeData();
double elapsed = timer.ticks();
EXPECT_TRUE(data.isValid());
EXPECT_GE(elapsed, 0.001);
EXPECT_LT(elapsed, 0.01);
}
TEST(SensorCaptureTest, VeryLowFrameRate)
{
MockSensorCapture sensor;
sensor.setFrameRate(2.0f); // 2 Hz = 500 ms per frame
sensor.resetTimer();
UTimer timer;
SensorData data = sensor.takeData();
double elapsed = timer.ticks();
EXPECT_TRUE(data.isValid());
EXPECT_GE(elapsed, 0.5);
EXPECT_LT(elapsed, 0.75); // allow scheduler jitter on loaded CI runners (e.g. macOS)
}