131 lines
3.5 KiB
C++
131 lines
3.5 KiB
C++
#ifdef WITH_TESTS
|
|
|
|
#include <cmath>
|
|
#include "../Tests.h"
|
|
#include "../../math/FixedFrequencyInterpolator.h"
|
|
#include <fstream>
|
|
#include <random>
|
|
|
|
/*
|
|
TEST(FixedFrequencyInterpolator, testOLD) {
|
|
|
|
FixedFrequencyInterpolator<float> ffi(Timestamp::fromMS(10));
|
|
|
|
std::ofstream out("/tmp/test.dat");
|
|
|
|
std::vector<float> data;
|
|
auto callback = [&] (const Timestamp ts, const float val) {
|
|
out << ts.ms() << " " << val << "\n";
|
|
data.push_back(val);
|
|
};
|
|
|
|
float x = 10;
|
|
|
|
// output should be a straight line
|
|
ffi.add(Timestamp::fromMS(55), x*55, callback);
|
|
ffi.add(Timestamp::fromMS(93), x*93, callback);
|
|
ffi.add(Timestamp::fromMS(102), x*102, callback);
|
|
ffi.add(Timestamp::fromMS(134), x*134, callback);
|
|
ffi.add(Timestamp::fromMS(212), x*212, callback);
|
|
ffi.add(Timestamp::fromMS(214), x*214, callback);
|
|
ffi.add(Timestamp::fromMS(216), x*216, callback);
|
|
ffi.add(Timestamp::fromMS(219), x*219, callback);
|
|
ffi.add(Timestamp::fromMS(220), x*220, callback);
|
|
ffi.add(Timestamp::fromMS(240), x*240, callback);
|
|
|
|
out.close();
|
|
|
|
const float d = 0.001;
|
|
ASSERT_NEAR(data[0], x*60, d);
|
|
ASSERT_NEAR(data[1], x*70, d);
|
|
ASSERT_NEAR(data[2], x*80, d);
|
|
ASSERT_NEAR(data[3], x*90, d);
|
|
ASSERT_NEAR(data[4], x*100, d);
|
|
ASSERT_NEAR(data[5], x*110, d);
|
|
ASSERT_NEAR(data[6], x*120, d);
|
|
ASSERT_NEAR(data[7], x*130, d);
|
|
ASSERT_NEAR(data[8], x*140, d);
|
|
ASSERT_NEAR(data[9], x*150, d);
|
|
ASSERT_NEAR(data[10], x*160, d);
|
|
ASSERT_NEAR(data[11], x*170, d);
|
|
ASSERT_NEAR(data[12], x*180, d);
|
|
ASSERT_NEAR(data[13], x*190, d);
|
|
ASSERT_NEAR(data[14], x*200, d);
|
|
ASSERT_NEAR(data[15], x*210, d);
|
|
ASSERT_NEAR(data[16], x*220, d);
|
|
ASSERT_NEAR(data[17], x*230, d);
|
|
ASSERT_NEAR(data[18], x*240, d);
|
|
|
|
}
|
|
*/
|
|
|
|
TEST(FixedFrequencyInterpolator, testNEW) {
|
|
|
|
FixedFrequencyInterpolator<float> ffi(Timestamp::fromMS(9));
|
|
|
|
// randomly draw points along a line using random intervals
|
|
Timestamp pos;
|
|
std::minstd_rand gen;
|
|
std::uniform_int_distribution<int> dist(2, 65);
|
|
auto func = [] (const Timestamp ts) {
|
|
return 0.5 * ts.ms() + 12;
|
|
};
|
|
|
|
// compare the randomly drawn points against interpolated fixed-frequency interpolated versions
|
|
auto cb = [&] (const Timestamp ts, const float val) {
|
|
ASSERT_NEAR(val, func(ts), 0.001); // interpolated vs original position on line
|
|
};
|
|
|
|
// run
|
|
for (int i = 0; i < 200; ++i) {
|
|
const float y = func(pos);
|
|
ffi.add(pos, y, cb);
|
|
pos += Timestamp::fromMS(dist(gen));
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
TEST(FixedFrequencyInterpolator, testUpsample) {
|
|
|
|
FixedFrequencyInterpolator<float> ffi(Timestamp::fromMS(10));
|
|
int cnt = 0;
|
|
|
|
auto cb = [&] (const Timestamp ts, const float f) {
|
|
if (cnt == 0) {ASSERT_EQ(ts.ms(), 0); ASSERT_NEAR( 0, f, 0.001);}
|
|
if (cnt == 1) {ASSERT_EQ(ts.ms(), 10); ASSERT_NEAR( 10, f, 0.001);}
|
|
if (cnt == 10) {ASSERT_EQ(ts.ms(),100); ASSERT_NEAR(100, f, 0.001);}
|
|
++cnt;
|
|
};
|
|
|
|
// add two entries. one at t=0 one at t=100. must be up-sampled into 11 entries (t=0, t=10, t=100)
|
|
ffi.add(Timestamp::fromMS(0), 0, cb);
|
|
ffi.add(Timestamp::fromMS(101), 101, cb);
|
|
ASSERT_EQ(11, cnt);
|
|
|
|
}
|
|
|
|
TEST(FixedFrequencyInterpolator, testDownsample) {
|
|
|
|
FixedFrequencyInterpolator<float> ffi(Timestamp::fromMS(50));
|
|
int cnt = 0;
|
|
|
|
auto cb = [&] (const Timestamp ts, const float f) {
|
|
if (cnt == 0) {ASSERT_EQ(ts.ms(), 0); ASSERT_NEAR( 0, f, 0.001);}
|
|
if (cnt == 1) {ASSERT_EQ(ts.ms(), 50); ASSERT_NEAR( 50, f, 0.001);}
|
|
if (cnt == 2) {ASSERT_EQ(ts.ms(), 100); ASSERT_NEAR(100, f, 0.001);}
|
|
++cnt;
|
|
};
|
|
|
|
// add 100+ entries in 1 ms steps. must be downsampled to 3 entries (t=0, t=50, t=100)
|
|
for (int i = 0; i <= 101; ++i) {
|
|
ffi.add(Timestamp::fromMS(i), i, cb);
|
|
}
|
|
ASSERT_EQ(3, cnt);
|
|
|
|
}
|
|
|
|
|
|
#endif
|