|
|
/*
|
|
|
* Copyright 2023 The Android Open Source Project
|
|
|
*
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
* you may not use this file except in compliance with the License.
|
|
|
* You may obtain a copy of the License at
|
|
|
*
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
*
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
* See the License for the specific language governing permissions and
|
|
|
* limitations under the License.
|
|
|
*/
|
|
|
|
|
|
#include <input/MotionPredictor.h>
|
|
|
|
|
|
#include <cmath>
|
|
|
#include <cstddef>
|
|
|
#include <cstdint>
|
|
|
#include <numeric>
|
|
|
#include <vector>
|
|
|
|
|
|
#include <gmock/gmock.h>
|
|
|
#include <gtest/gtest.h>
|
|
|
#include <input/InputEventBuilders.h>
|
|
|
#include <utils/Timers.h> // for nsecs_t
|
|
|
|
|
|
#include "Eigen/Core"
|
|
|
#include "Eigen/Geometry"
|
|
|
|
|
|
namespace android {
|
|
|
namespace {
|
|
|
|
|
|
using ::testing::FloatNear;
|
|
|
using ::testing::Matches;
|
|
|
|
|
|
using GroundTruthPoint = MotionPredictorMetricsManager::GroundTruthPoint;
|
|
|
using PredictionPoint = MotionPredictorMetricsManager::PredictionPoint;
|
|
|
using AtomFields = MotionPredictorMetricsManager::AtomFields;
|
|
|
|
|
|
inline constexpr int NANOS_PER_MILLIS = 1'000'000;
|
|
|
|
|
|
inline constexpr nsecs_t TEST_INITIAL_TIMESTAMP = 1'000'000'000;
|
|
|
inline constexpr size_t TEST_MAX_NUM_PREDICTIONS = 5;
|
|
|
inline constexpr nsecs_t TEST_PREDICTION_INTERVAL_NANOS = 12'500'000 / 3; // 1 / (240 hz)
|
|
|
inline constexpr int NO_DATA_SENTINEL = MotionPredictorMetricsManager::NO_DATA_SENTINEL;
|
|
|
|
|
|
// Parameters:
|
|
|
// • arg: Eigen::Vector2f
|
|
|
// • target: Eigen::Vector2f
|
|
|
// • epsilon: float
|
|
|
MATCHER_P2(Vector2fNear, target, epsilon, "") {
|
|
|
return Matches(FloatNear(target[0], epsilon))(arg[0]) &&
|
|
|
Matches(FloatNear(target[1], epsilon))(arg[1]);
|
|
|
}
|
|
|
|
|
|
// Parameters:
|
|
|
// • arg: PredictionPoint
|
|
|
// • target: PredictionPoint
|
|
|
// • epsilon: float
|
|
|
MATCHER_P2(PredictionPointNear, target, epsilon, "") {
|
|
|
if (!Matches(Vector2fNear(target.position, epsilon))(arg.position)) {
|
|
|
*result_listener << "Position mismatch. Actual: (" << arg.position[0] << ", "
|
|
|
<< arg.position[1] << "), expected: (" << target.position[0] << ", "
|
|
|
<< target.position[1] << ")";
|
|
|
return false;
|
|
|
}
|
|
|
if (!Matches(FloatNear(target.pressure, epsilon))(arg.pressure)) {
|
|
|
*result_listener << "Pressure mismatch. Actual: " << arg.pressure
|
|
|
<< ", expected: " << target.pressure;
|
|
|
return false;
|
|
|
}
|
|
|
if (arg.originTimestamp != target.originTimestamp) {
|
|
|
*result_listener << "Origin timestamp mismatch. Actual: " << arg.originTimestamp
|
|
|
<< ", expected: " << target.originTimestamp;
|
|
|
return false;
|
|
|
}
|
|
|
if (arg.targetTimestamp != target.targetTimestamp) {
|
|
|
*result_listener << "Target timestamp mismatch. Actual: " << arg.targetTimestamp
|
|
|
<< ", expected: " << target.targetTimestamp;
|
|
|
return false;
|
|
|
}
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
// --- Mathematical helper functions. ---
|
|
|
|
|
|
template <typename T>
|
|
|
T average(std::vector<T> values) {
|
|
|
return std::accumulate(values.begin(), values.end(), T{}) / static_cast<T>(values.size());
|
|
|
}
|
|
|
|
|
|
template <typename T>
|
|
|
T standardDeviation(std::vector<T> values) {
|
|
|
T mean = average(values);
|
|
|
T accumulator = {};
|
|
|
for (const T value : values) {
|
|
|
accumulator += value * value - mean * mean;
|
|
|
}
|
|
|
// Take the max with 0 to avoid negative values caused by numerical instability.
|
|
|
return std::sqrt(std::max(T{}, accumulator) / static_cast<T>(values.size()));
|
|
|
}
|
|
|
|
|
|
template <typename T>
|
|
|
T rmse(std::vector<T> errors) {
|
|
|
T sse = {};
|
|
|
for (const T error : errors) {
|
|
|
sse += error * error;
|
|
|
}
|
|
|
return std::sqrt(sse / static_cast<T>(errors.size()));
|
|
|
}
|
|
|
|
|
|
TEST(MathematicalHelperFunctionTest, Average) {
|
|
|
std::vector<float> values{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
|
|
|
EXPECT_EQ(5.5f, average(values));
|
|
|
}
|
|
|
|
|
|
TEST(MathematicalHelperFunctionTest, StandardDeviation) {
|
|
|
// https://www.calculator.net/standard-deviation-calculator.html?numberinputs=10%2C+12%2C+23%2C+23%2C+16%2C+23%2C+21%2C+16
|
|
|
std::vector<float> values{10, 12, 23, 23, 16, 23, 21, 16};
|
|
|
EXPECT_FLOAT_EQ(4.8989794855664f, standardDeviation(values));
|
|
|
}
|
|
|
|
|
|
TEST(MathematicalHelperFunctionTest, Rmse) {
|
|
|
std::vector<float> errors{1, 5, 7, 7, 8, 20};
|
|
|
EXPECT_FLOAT_EQ(9.899494937f, rmse(errors));
|
|
|
}
|
|
|
|
|
|
// --- MotionEvent-related helper functions. ---
|
|
|
|
|
|
// Creates a MotionEvent corresponding to the given GroundTruthPoint.
|
|
|
MotionEvent makeMotionEvent(const GroundTruthPoint& groundTruthPoint) {
|
|
|
// Build single pointer of type STYLUS, with coordinates from groundTruthPoint.
|
|
|
PointerBuilder pointerBuilder =
|
|
|
PointerBuilder(/*id=*/0, ToolType::STYLUS)
|
|
|
.x(groundTruthPoint.position[1])
|
|
|
.y(groundTruthPoint.position[0])
|
|
|
.axis(AMOTION_EVENT_AXIS_PRESSURE, groundTruthPoint.pressure);
|
|
|
return MotionEventBuilder(/*action=*/AMOTION_EVENT_ACTION_MOVE,
|
|
|
/*source=*/AINPUT_SOURCE_CLASS_POINTER)
|
|
|
.eventTime(groundTruthPoint.timestamp)
|
|
|
.pointer(pointerBuilder)
|
|
|
.build();
|
|
|
}
|
|
|
|
|
|
// Creates a MotionEvent corresponding to the given sequence of PredictionPoints.
|
|
|
MotionEvent makeMotionEvent(const std::vector<PredictionPoint>& predictionPoints) {
|
|
|
// Build single pointer of type STYLUS, with coordinates from first prediction point.
|
|
|
PointerBuilder pointerBuilder =
|
|
|
PointerBuilder(/*id=*/0, ToolType::STYLUS)
|
|
|
.x(predictionPoints[0].position[1])
|
|
|
.y(predictionPoints[0].position[0])
|
|
|
.axis(AMOTION_EVENT_AXIS_PRESSURE, predictionPoints[0].pressure);
|
|
|
MotionEvent predictionEvent =
|
|
|
MotionEventBuilder(
|
|
|
/*action=*/AMOTION_EVENT_ACTION_MOVE, /*source=*/AINPUT_SOURCE_CLASS_POINTER)
|
|
|
.eventTime(predictionPoints[0].targetTimestamp)
|
|
|
.pointer(pointerBuilder)
|
|
|
.build();
|
|
|
for (size_t i = 1; i < predictionPoints.size(); ++i) {
|
|
|
PointerCoords coords =
|
|
|
PointerBuilder(/*id=*/0, ToolType::STYLUS)
|
|
|
.x(predictionPoints[i].position[1])
|
|
|
.y(predictionPoints[i].position[0])
|
|
|
.axis(AMOTION_EVENT_AXIS_PRESSURE, predictionPoints[i].pressure)
|
|
|
.buildCoords();
|
|
|
predictionEvent.addSample(predictionPoints[i].targetTimestamp, &coords);
|
|
|
}
|
|
|
return predictionEvent;
|
|
|
}
|
|
|
|
|
|
// Creates a MotionEvent corresponding to a stylus lift (UP) ground truth event.
|
|
|
MotionEvent makeLiftMotionEvent() {
|
|
|
return MotionEventBuilder(/*action=*/AMOTION_EVENT_ACTION_UP,
|
|
|
/*source=*/AINPUT_SOURCE_CLASS_POINTER)
|
|
|
.pointer(PointerBuilder(/*id=*/0, ToolType::STYLUS))
|
|
|
.build();
|
|
|
}
|
|
|
|
|
|
TEST(MakeMotionEventTest, MakeGroundTruthMotionEvent) {
|
|
|
const GroundTruthPoint groundTruthPoint{{.position = Eigen::Vector2f(10.0f, 20.0f),
|
|
|
.pressure = 0.6f},
|
|
|
.timestamp = TEST_INITIAL_TIMESTAMP};
|
|
|
const MotionEvent groundTruthMotionEvent = makeMotionEvent(groundTruthPoint);
|
|
|
|
|
|
ASSERT_EQ(1u, groundTruthMotionEvent.getPointerCount());
|
|
|
// Note: a MotionEvent's "history size" is one less than its number of samples.
|
|
|
ASSERT_EQ(0u, groundTruthMotionEvent.getHistorySize());
|
|
|
EXPECT_EQ(groundTruthPoint.position[0], groundTruthMotionEvent.getRawPointerCoords(0)->getY());
|
|
|
EXPECT_EQ(groundTruthPoint.position[1], groundTruthMotionEvent.getRawPointerCoords(0)->getX());
|
|
|
EXPECT_EQ(groundTruthPoint.pressure,
|
|
|
groundTruthMotionEvent.getRawPointerCoords(0)->getAxisValue(
|
|
|
AMOTION_EVENT_AXIS_PRESSURE));
|
|
|
EXPECT_EQ(AMOTION_EVENT_ACTION_MOVE, groundTruthMotionEvent.getAction());
|
|
|
}
|
|
|
|
|
|
TEST(MakeMotionEventTest, MakePredictionMotionEvent) {
|
|
|
const nsecs_t originTimestamp = TEST_INITIAL_TIMESTAMP;
|
|
|
const std::vector<PredictionPoint>
|
|
|
predictionPoints{{{.position = Eigen::Vector2f(10.0f, 20.0f), .pressure = 0.6f},
|
|
|
.originTimestamp = originTimestamp,
|
|
|
.targetTimestamp = originTimestamp + 5 * NANOS_PER_MILLIS},
|
|
|
{{.position = Eigen::Vector2f(11.0f, 22.0f), .pressure = 0.5f},
|
|
|
.originTimestamp = originTimestamp,
|
|
|
.targetTimestamp = originTimestamp + 10 * NANOS_PER_MILLIS},
|
|
|
{{.position = Eigen::Vector2f(12.0f, 24.0f), .pressure = 0.4f},
|
|
|
.originTimestamp = originTimestamp,
|
|
|
.targetTimestamp = originTimestamp + 15 * NANOS_PER_MILLIS}};
|
|
|
const MotionEvent predictionMotionEvent = makeMotionEvent(predictionPoints);
|
|
|
|
|
|
ASSERT_EQ(1u, predictionMotionEvent.getPointerCount());
|
|
|
// Note: a MotionEvent's "history size" is one less than its number of samples.
|
|
|
ASSERT_EQ(predictionPoints.size(), predictionMotionEvent.getHistorySize() + 1);
|
|
|
for (size_t i = 0; i < predictionPoints.size(); ++i) {
|
|
|
SCOPED_TRACE(testing::Message() << "i = " << i);
|
|
|
const PointerCoords coords = *predictionMotionEvent.getHistoricalRawPointerCoords(
|
|
|
/*pointerIndex=*/0, /*historicalIndex=*/i);
|
|
|
EXPECT_EQ(predictionPoints[i].position[0], coords.getY());
|
|
|
EXPECT_EQ(predictionPoints[i].position[1], coords.getX());
|
|
|
EXPECT_EQ(predictionPoints[i].pressure, coords.getAxisValue(AMOTION_EVENT_AXIS_PRESSURE));
|
|
|
// Note: originTimestamp is discarded when converting PredictionPoint to MotionEvent.
|
|
|
EXPECT_EQ(predictionPoints[i].targetTimestamp,
|
|
|
predictionMotionEvent.getHistoricalEventTime(i));
|
|
|
EXPECT_EQ(AMOTION_EVENT_ACTION_MOVE, predictionMotionEvent.getAction());
|
|
|
}
|
|
|
}
|
|
|
|
|
|
TEST(MakeMotionEventTest, MakeLiftMotionEvent) {
|
|
|
const MotionEvent liftMotionEvent = makeLiftMotionEvent();
|
|
|
ASSERT_EQ(1u, liftMotionEvent.getPointerCount());
|
|
|
// Note: a MotionEvent's "history size" is one less than its number of samples.
|
|
|
ASSERT_EQ(0u, liftMotionEvent.getHistorySize());
|
|
|
EXPECT_EQ(AMOTION_EVENT_ACTION_UP, liftMotionEvent.getAction());
|
|
|
}
|
|
|
|
|
|
// --- Ground-truth-generation helper functions. ---
|
|
|
|
|
|
std::vector<GroundTruthPoint> generateConstantGroundTruthPoints(
|
|
|
const GroundTruthPoint& groundTruthPoint, size_t numPoints) {
|
|
|
std::vector<GroundTruthPoint> groundTruthPoints;
|
|
|
nsecs_t timestamp = groundTruthPoint.timestamp;
|
|
|
for (size_t i = 0; i < numPoints; ++i) {
|
|
|
groundTruthPoints.emplace_back(groundTruthPoint);
|
|
|
groundTruthPoints.back().timestamp = timestamp;
|
|
|
timestamp += TEST_PREDICTION_INTERVAL_NANOS;
|
|
|
}
|
|
|
return groundTruthPoints;
|
|
|
}
|
|
|
|
|
|
// This function uses the coordinate system (y, x), with +y pointing downwards and +x pointing
|
|
|
// rightwards. Angles are measured counterclockwise from down (+y).
|
|
|
std::vector<GroundTruthPoint> generateCircularArcGroundTruthPoints(Eigen::Vector2f initialPosition,
|
|
|
float initialAngle,
|
|
|
float velocity,
|
|
|
float turningAngle,
|
|
|
size_t numPoints) {
|
|
|
std::vector<GroundTruthPoint> groundTruthPoints;
|
|
|
// Create first point.
|
|
|
if (numPoints > 0) {
|
|
|
groundTruthPoints.push_back({{.position = initialPosition, .pressure = 0.0f},
|
|
|
.timestamp = TEST_INITIAL_TIMESTAMP});
|
|
|
}
|
|
|
float trajectoryAngle = initialAngle; // measured counterclockwise from +y axis.
|
|
|
for (size_t i = 1; i < numPoints; ++i) {
|
|
|
const Eigen::Vector2f trajectory =
|
|
|
Eigen::Rotation2D(trajectoryAngle) * Eigen::Vector2f(1, 0);
|
|
|
groundTruthPoints.push_back(
|
|
|
{{.position = groundTruthPoints.back().position + velocity * trajectory,
|
|
|
.pressure = 0.0f},
|
|
|
.timestamp = groundTruthPoints.back().timestamp + TEST_PREDICTION_INTERVAL_NANOS});
|
|
|
trajectoryAngle += turningAngle;
|
|
|
}
|
|
|
return groundTruthPoints;
|
|
|
}
|
|
|
|
|
|
TEST(GenerateConstantGroundTruthPointsTest, BasicTest) {
|
|
|
const GroundTruthPoint groundTruthPoint{{.position = Eigen::Vector2f(10, 20), .pressure = 0.3f},
|
|
|
.timestamp = TEST_INITIAL_TIMESTAMP};
|
|
|
const std::vector<GroundTruthPoint> groundTruthPoints =
|
|
|
generateConstantGroundTruthPoints(groundTruthPoint, /*numPoints=*/3);
|
|
|
|
|
|
ASSERT_EQ(3u, groundTruthPoints.size());
|
|
|
// First point.
|
|
|
EXPECT_EQ(groundTruthPoints[0].position, groundTruthPoint.position);
|
|
|
EXPECT_EQ(groundTruthPoints[0].pressure, groundTruthPoint.pressure);
|
|
|
EXPECT_EQ(groundTruthPoints[0].timestamp, groundTruthPoint.timestamp);
|
|
|
// Second point.
|
|
|
EXPECT_EQ(groundTruthPoints[1].position, groundTruthPoint.position);
|
|
|
EXPECT_EQ(groundTruthPoints[1].pressure, groundTruthPoint.pressure);
|
|
|
EXPECT_GT(groundTruthPoints[1].timestamp, groundTruthPoints[0].timestamp);
|
|
|
// Third point.
|
|
|
EXPECT_EQ(groundTruthPoints[2].position, groundTruthPoint.position);
|
|
|
EXPECT_EQ(groundTruthPoints[2].pressure, groundTruthPoint.pressure);
|
|
|
EXPECT_GT(groundTruthPoints[2].timestamp, groundTruthPoints[1].timestamp);
|
|
|
}
|
|
|
|
|
|
TEST(GenerateCircularArcGroundTruthTest, StraightLineUpwards) {
|
|
|
const std::vector<GroundTruthPoint> groundTruthPoints = generateCircularArcGroundTruthPoints(
|
|
|
/*initialPosition=*/Eigen::Vector2f(0, 0),
|
|
|
/*initialAngle=*/M_PI,
|
|
|
/*velocity=*/1.0f,
|
|
|
/*turningAngle=*/0.0f,
|
|
|
/*numPoints=*/3);
|
|
|
|
|
|
ASSERT_EQ(3u, groundTruthPoints.size());
|
|
|
EXPECT_THAT(groundTruthPoints[0].position, Vector2fNear(Eigen::Vector2f(0, 0), 1e-6));
|
|
|
EXPECT_THAT(groundTruthPoints[1].position, Vector2fNear(Eigen::Vector2f(-1, 0), 1e-6));
|
|
|
EXPECT_THAT(groundTruthPoints[2].position, Vector2fNear(Eigen::Vector2f(-2, 0), 1e-6));
|
|
|
// Check that timestamps are increasing between consecutive ground truth points.
|
|
|
EXPECT_GT(groundTruthPoints[1].timestamp, groundTruthPoints[0].timestamp);
|
|
|
EXPECT_GT(groundTruthPoints[2].timestamp, groundTruthPoints[1].timestamp);
|
|
|
}
|
|
|
|
|
|
TEST(GenerateCircularArcGroundTruthTest, CounterclockwiseSquare) {
|
|
|
// Generate points in a counterclockwise unit square starting pointing right.
|
|
|
const std::vector<GroundTruthPoint> groundTruthPoints = generateCircularArcGroundTruthPoints(
|
|
|
/*initialPosition=*/Eigen::Vector2f(10, 100),
|
|
|
/*initialAngle=*/M_PI_2,
|
|
|
/*velocity=*/1.0f,
|
|
|
/*turningAngle=*/M_PI_2,
|
|
|
/*numPoints=*/5);
|
|
|
|
|
|
ASSERT_EQ(5u, groundTruthPoints.size());
|
|
|
EXPECT_THAT(groundTruthPoints[0].position, Vector2fNear(Eigen::Vector2f(10, 100), 1e-6));
|
|
|
EXPECT_THAT(groundTruthPoints[1].position, Vector2fNear(Eigen::Vector2f(10, 101), 1e-6));
|
|
|
EXPECT_THAT(groundTruthPoints[2].position, Vector2fNear(Eigen::Vector2f(9, 101), 1e-6));
|
|
|
EXPECT_THAT(groundTruthPoints[3].position, Vector2fNear(Eigen::Vector2f(9, 100), 1e-6));
|
|
|
EXPECT_THAT(groundTruthPoints[4].position, Vector2fNear(Eigen::Vector2f(10, 100), 1e-6));
|
|
|
}
|
|
|
|
|
|
// --- Prediction-generation helper functions. ---
|
|
|
|
|
|
// Creates a sequence of predictions with values equal to those of the given GroundTruthPoint.
|
|
|
std::vector<PredictionPoint> generateConstantPredictions(const GroundTruthPoint& groundTruthPoint) {
|
|
|
std::vector<PredictionPoint> predictions;
|
|
|
nsecs_t predictionTimestamp = groundTruthPoint.timestamp + TEST_PREDICTION_INTERVAL_NANOS;
|
|
|
for (size_t j = 0; j < TEST_MAX_NUM_PREDICTIONS; ++j) {
|
|
|
predictions.push_back(PredictionPoint{{.position = groundTruthPoint.position,
|
|
|
.pressure = groundTruthPoint.pressure},
|
|
|
.originTimestamp = groundTruthPoint.timestamp,
|
|
|
.targetTimestamp = predictionTimestamp});
|
|
|
predictionTimestamp += TEST_PREDICTION_INTERVAL_NANOS;
|
|
|
}
|
|
|
return predictions;
|
|
|
}
|
|
|
|
|
|
// Generates TEST_MAX_NUM_PREDICTIONS predictions from the given most recent two ground truth points
|
|
|
// by linear extrapolation of position and pressure. The interval between consecutive predictions'
|
|
|
// timestamps is TEST_PREDICTION_INTERVAL_NANOS.
|
|
|
std::vector<PredictionPoint> generatePredictionsByLinearExtrapolation(
|
|
|
const GroundTruthPoint& firstGroundTruth, const GroundTruthPoint& secondGroundTruth) {
|
|
|
// Precompute deltas.
|
|
|
const Eigen::Vector2f trajectory = secondGroundTruth.position - firstGroundTruth.position;
|
|
|
const float deltaPressure = secondGroundTruth.pressure - firstGroundTruth.pressure;
|
|
|
// Compute predictions.
|
|
|
std::vector<PredictionPoint> predictions;
|
|
|
Eigen::Vector2f predictionPosition = secondGroundTruth.position;
|
|
|
float predictionPressure = secondGroundTruth.pressure;
|
|
|
nsecs_t predictionTargetTimestamp = secondGroundTruth.timestamp;
|
|
|
for (size_t i = 0; i < TEST_MAX_NUM_PREDICTIONS; ++i) {
|
|
|
predictionPosition += trajectory;
|
|
|
predictionPressure += deltaPressure;
|
|
|
predictionTargetTimestamp += TEST_PREDICTION_INTERVAL_NANOS;
|
|
|
predictions.push_back(
|
|
|
PredictionPoint{{.position = predictionPosition, .pressure = predictionPressure},
|
|
|
.originTimestamp = secondGroundTruth.timestamp,
|
|
|
.targetTimestamp = predictionTargetTimestamp});
|
|
|
}
|
|
|
return predictions;
|
|
|
}
|
|
|
|
|
|
TEST(GeneratePredictionsTest, GenerateConstantPredictions) {
|
|
|
const GroundTruthPoint groundTruthPoint{{.position = Eigen::Vector2f(10, 20), .pressure = 0.3f},
|
|
|
.timestamp = TEST_INITIAL_TIMESTAMP};
|
|
|
const std::vector<PredictionPoint> predictionPoints =
|
|
|
generateConstantPredictions(groundTruthPoint);
|
|
|
|
|
|
ASSERT_EQ(TEST_MAX_NUM_PREDICTIONS, predictionPoints.size());
|
|
|
for (size_t i = 0; i < predictionPoints.size(); ++i) {
|
|
|
SCOPED_TRACE(testing::Message() << "i = " << i);
|
|
|
EXPECT_THAT(predictionPoints[i].position, Vector2fNear(groundTruthPoint.position, 1e-6));
|
|
|
EXPECT_THAT(predictionPoints[i].pressure, FloatNear(groundTruthPoint.pressure, 1e-6));
|
|
|
EXPECT_EQ(predictionPoints[i].originTimestamp, groundTruthPoint.timestamp);
|
|
|
EXPECT_EQ(predictionPoints[i].targetTimestamp,
|
|
|
groundTruthPoint.timestamp +
|
|
|
static_cast<nsecs_t>(i + 1) * TEST_PREDICTION_INTERVAL_NANOS);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
TEST(GeneratePredictionsTest, LinearExtrapolationFromTwoPoints) {
|
|
|
const nsecs_t initialTimestamp = TEST_INITIAL_TIMESTAMP;
|
|
|
const std::vector<PredictionPoint> predictionPoints = generatePredictionsByLinearExtrapolation(
|
|
|
GroundTruthPoint{{.position = Eigen::Vector2f(100, 200), .pressure = 0.9f},
|
|
|
.timestamp = initialTimestamp},
|
|
|
GroundTruthPoint{{.position = Eigen::Vector2f(105, 190), .pressure = 0.8f},
|
|
|
.timestamp = initialTimestamp + TEST_PREDICTION_INTERVAL_NANOS});
|
|
|
|
|
|
ASSERT_EQ(TEST_MAX_NUM_PREDICTIONS, predictionPoints.size());
|
|
|
const nsecs_t originTimestamp = initialTimestamp + TEST_PREDICTION_INTERVAL_NANOS;
|
|
|
EXPECT_THAT(predictionPoints[0],
|
|
|
PredictionPointNear(PredictionPoint{{.position = Eigen::Vector2f(110, 180),
|
|
|
.pressure = 0.7f},
|
|
|
.originTimestamp = originTimestamp,
|
|
|
.targetTimestamp = originTimestamp +
|
|
|
TEST_PREDICTION_INTERVAL_NANOS},
|
|
|
0.001));
|
|
|
EXPECT_THAT(predictionPoints[1],
|
|
|
PredictionPointNear(PredictionPoint{{.position = Eigen::Vector2f(115, 170),
|
|
|
.pressure = 0.6f},
|
|
|
.originTimestamp = originTimestamp,
|
|
|
.targetTimestamp = originTimestamp +
|
|
|
2 * TEST_PREDICTION_INTERVAL_NANOS},
|
|
|
0.001));
|
|
|
EXPECT_THAT(predictionPoints[2],
|
|
|
PredictionPointNear(PredictionPoint{{.position = Eigen::Vector2f(120, 160),
|
|
|
.pressure = 0.5f},
|
|
|
.originTimestamp = originTimestamp,
|
|
|
.targetTimestamp = originTimestamp +
|
|
|
3 * TEST_PREDICTION_INTERVAL_NANOS},
|
|
|
0.001));
|
|
|
EXPECT_THAT(predictionPoints[3],
|
|
|
PredictionPointNear(PredictionPoint{{.position = Eigen::Vector2f(125, 150),
|
|
|
.pressure = 0.4f},
|
|
|
.originTimestamp = originTimestamp,
|
|
|
.targetTimestamp = originTimestamp +
|
|
|
4 * TEST_PREDICTION_INTERVAL_NANOS},
|
|
|
0.001));
|
|
|
EXPECT_THAT(predictionPoints[4],
|
|
|
PredictionPointNear(PredictionPoint{{.position = Eigen::Vector2f(130, 140),
|
|
|
.pressure = 0.3f},
|
|
|
.originTimestamp = originTimestamp,
|
|
|
.targetTimestamp = originTimestamp +
|
|
|
5 * TEST_PREDICTION_INTERVAL_NANOS},
|
|
|
0.001));
|
|
|
}
|
|
|
|
|
|
// Generates predictions by linear extrapolation for each consecutive pair of ground truth points
|
|
|
// (see the comment for the above function for further explanation). Returns a vector of vectors of
|
|
|
// prediction points, where the first index is the source ground truth index, and the second is the
|
|
|
// prediction target index.
|
|
|
//
|
|
|
// The returned vector has size equal to the input vector, and the first element of the returned
|
|
|
// vector is always empty.
|
|
|
std::vector<std::vector<PredictionPoint>> generateAllPredictionsByLinearExtrapolation(
|
|
|
const std::vector<GroundTruthPoint>& groundTruthPoints) {
|
|
|
std::vector<std::vector<PredictionPoint>> allPredictions;
|
|
|
allPredictions.emplace_back();
|
|
|
for (size_t i = 1; i < groundTruthPoints.size(); ++i) {
|
|
|
allPredictions.push_back(generatePredictionsByLinearExtrapolation(groundTruthPoints[i - 1],
|
|
|
groundTruthPoints[i]));
|
|
|
}
|
|
|
return allPredictions;
|
|
|
}
|
|
|
|
|
|
TEST(GeneratePredictionsTest, GenerateAllPredictions) {
|
|
|
const nsecs_t initialTimestamp = TEST_INITIAL_TIMESTAMP;
|
|
|
std::vector<GroundTruthPoint>
|
|
|
groundTruthPoints{GroundTruthPoint{{.position = Eigen::Vector2f(0, 0),
|
|
|
.pressure = 0.5f},
|
|
|
.timestamp = initialTimestamp},
|
|
|
GroundTruthPoint{{.position = Eigen::Vector2f(1, -1),
|
|
|
.pressure = 0.51f},
|
|
|
.timestamp = initialTimestamp +
|
|
|
2 * TEST_PREDICTION_INTERVAL_NANOS},
|
|
|
GroundTruthPoint{{.position = Eigen::Vector2f(2, -2),
|
|
|
.pressure = 0.52f},
|
|
|
.timestamp = initialTimestamp +
|
|
|
3 * TEST_PREDICTION_INTERVAL_NANOS}};
|
|
|
|
|
|
const std::vector<std::vector<PredictionPoint>> allPredictions =
|
|
|
generateAllPredictionsByLinearExtrapolation(groundTruthPoints);
|
|
|
|
|
|
// Check format of allPredictions data.
|
|
|
ASSERT_EQ(groundTruthPoints.size(), allPredictions.size());
|
|
|
EXPECT_TRUE(allPredictions[0].empty());
|
|
|
EXPECT_EQ(TEST_MAX_NUM_PREDICTIONS, allPredictions[1].size());
|
|
|
EXPECT_EQ(TEST_MAX_NUM_PREDICTIONS, allPredictions[2].size());
|
|
|
|
|
|
// Check positions of predictions generated from first pair of ground truth points.
|
|
|
EXPECT_THAT(allPredictions[1][0].position, Vector2fNear(Eigen::Vector2f(2, -2), 1e-9));
|
|
|
EXPECT_THAT(allPredictions[1][1].position, Vector2fNear(Eigen::Vector2f(3, -3), 1e-9));
|
|
|
EXPECT_THAT(allPredictions[1][2].position, Vector2fNear(Eigen::Vector2f(4, -4), 1e-9));
|
|
|
EXPECT_THAT(allPredictions[1][3].position, Vector2fNear(Eigen::Vector2f(5, -5), 1e-9));
|
|
|
EXPECT_THAT(allPredictions[1][4].position, Vector2fNear(Eigen::Vector2f(6, -6), 1e-9));
|
|
|
|
|
|
// Check pressures of predictions generated from first pair of ground truth points.
|
|
|
EXPECT_FLOAT_EQ(0.52f, allPredictions[1][0].pressure);
|
|
|
EXPECT_FLOAT_EQ(0.53f, allPredictions[1][1].pressure);
|
|
|
EXPECT_FLOAT_EQ(0.54f, allPredictions[1][2].pressure);
|
|
|
EXPECT_FLOAT_EQ(0.55f, allPredictions[1][3].pressure);
|
|
|
EXPECT_FLOAT_EQ(0.56f, allPredictions[1][4].pressure);
|
|
|
}
|
|
|
|
|
|
// --- Prediction error helper functions. ---
|
|
|
|
|
|
struct GeneralPositionErrors {
|
|
|
float alongTrajectoryErrorMean;
|
|
|
float alongTrajectoryErrorStd;
|
|
|
float offTrajectoryRmse;
|
|
|
};
|
|
|
|
|
|
// Inputs:
|
|
|
// • Vector of ground truth points
|
|
|
// • Vector of vectors of prediction points, where the first index is the source ground truth
|
|
|
// index, and the second is the prediction target index.
|
|
|
//
|
|
|
// Returns a vector of GeneralPositionErrors, indexed by prediction time delta bucket.
|
|
|
std::vector<GeneralPositionErrors> computeGeneralPositionErrors(
|
|
|
const std::vector<GroundTruthPoint>& groundTruthPoints,
|
|
|
const std::vector<std::vector<PredictionPoint>>& predictionPoints) {
|
|
|
// Aggregate errors by time bucket (prediction target index).
|
|
|
std::vector<GeneralPositionErrors> generalPostitionErrors;
|
|
|
for (size_t predictionTargetIndex = 0; predictionTargetIndex < TEST_MAX_NUM_PREDICTIONS;
|
|
|
++predictionTargetIndex) {
|
|
|
std::vector<float> alongTrajectoryErrors;
|
|
|
std::vector<float> alongTrajectorySquaredErrors;
|
|
|
std::vector<float> offTrajectoryErrors;
|
|
|
for (size_t sourceGroundTruthIndex = 1; sourceGroundTruthIndex < groundTruthPoints.size();
|
|
|
++sourceGroundTruthIndex) {
|
|
|
const size_t targetGroundTruthIndex =
|
|
|
sourceGroundTruthIndex + predictionTargetIndex + 1;
|
|
|
// Only include errors for points with a ground truth value.
|
|
|
if (targetGroundTruthIndex < groundTruthPoints.size()) {
|
|
|
const Eigen::Vector2f trajectory =
|
|
|
(groundTruthPoints[targetGroundTruthIndex].position -
|
|
|
groundTruthPoints[targetGroundTruthIndex - 1].position)
|
|
|
.normalized();
|
|
|
const Eigen::Vector2f orthogonalTrajectory =
|
|
|
Eigen::Rotation2Df(M_PI_2) * trajectory;
|
|
|
const Eigen::Vector2f positionError =
|
|
|
predictionPoints[sourceGroundTruthIndex][predictionTargetIndex].position -
|
|
|
groundTruthPoints[targetGroundTruthIndex].position;
|
|
|
alongTrajectoryErrors.push_back(positionError.dot(trajectory));
|
|
|
alongTrajectorySquaredErrors.push_back(alongTrajectoryErrors.back() *
|
|
|
alongTrajectoryErrors.back());
|
|
|
offTrajectoryErrors.push_back(positionError.dot(orthogonalTrajectory));
|
|
|
}
|
|
|
}
|
|
|
generalPostitionErrors.push_back(
|
|
|
{.alongTrajectoryErrorMean = average(alongTrajectoryErrors),
|
|
|
.alongTrajectoryErrorStd = standardDeviation(alongTrajectoryErrors),
|
|
|
.offTrajectoryRmse = rmse(offTrajectoryErrors)});
|
|
|
}
|
|
|
return generalPostitionErrors;
|
|
|
}
|
|
|
|
|
|
// Inputs:
|
|
|
// • Vector of ground truth points
|
|
|
// • Vector of vectors of prediction points, where the first index is the source ground truth
|
|
|
// index, and the second is the prediction target index.
|
|
|
//
|
|
|
// Returns a vector of pressure RMSEs, indexed by prediction time delta bucket.
|
|
|
std::vector<float> computePressureRmses(
|
|
|
const std::vector<GroundTruthPoint>& groundTruthPoints,
|
|
|
const std::vector<std::vector<PredictionPoint>>& predictionPoints) {
|
|
|
// Aggregate errors by time bucket (prediction target index).
|
|
|
std::vector<float> pressureRmses;
|
|
|
for (size_t predictionTargetIndex = 0; predictionTargetIndex < TEST_MAX_NUM_PREDICTIONS;
|
|
|
++predictionTargetIndex) {
|
|
|
std::vector<float> pressureErrors;
|
|
|
for (size_t sourceGroundTruthIndex = 1; sourceGroundTruthIndex < groundTruthPoints.size();
|
|
|
++sourceGroundTruthIndex) {
|
|
|
const size_t targetGroundTruthIndex =
|
|
|
sourceGroundTruthIndex + predictionTargetIndex + 1;
|
|
|
// Only include errors for points with a ground truth value.
|
|
|
if (targetGroundTruthIndex < groundTruthPoints.size()) {
|
|
|
pressureErrors.push_back(
|
|
|
predictionPoints[sourceGroundTruthIndex][predictionTargetIndex].pressure -
|
|
|
groundTruthPoints[targetGroundTruthIndex].pressure);
|
|
|
}
|
|
|
}
|
|
|
pressureRmses.push_back(rmse(pressureErrors));
|
|
|
}
|
|
|
return pressureRmses;
|
|
|
}
|
|
|
|
|
|
TEST(ErrorComputationHelperTest, ComputeGeneralPositionErrorsSimpleTest) {
|
|
|
std::vector<GroundTruthPoint> groundTruthPoints =
|
|
|
generateConstantGroundTruthPoints(GroundTruthPoint{{.position = Eigen::Vector2f(0, 0),
|
|
|
.pressure = 0.0f},
|
|
|
.timestamp = TEST_INITIAL_TIMESTAMP},
|
|
|
/*numPoints=*/TEST_MAX_NUM_PREDICTIONS + 2);
|
|
|
groundTruthPoints[3].position = Eigen::Vector2f(1, 0);
|
|
|
groundTruthPoints[4].position = Eigen::Vector2f(1, 1);
|
|
|
groundTruthPoints[5].position = Eigen::Vector2f(1, 3);
|
|
|
groundTruthPoints[6].position = Eigen::Vector2f(2, 3);
|
|
|
|
|
|
std::vector<std::vector<PredictionPoint>> predictionPoints =
|
|
|
generateAllPredictionsByLinearExtrapolation(groundTruthPoints);
|
|
|
|
|
|
// The generated predictions look like:
|
|
|
//
|
|
|
// | Source | Target Ground Truth Index |
|
|
|
// | Index | 2 | 3 | 4 | 5 | 6 |
|
|
|
// |------------|--------|--------|--------|--------|--------|
|
|
|
// | 1 | (0, 0) | (0, 0) | (0, 0) | (0, 0) | (0, 0) |
|
|
|
// | 2 | | (0, 0) | (0, 0) | (0, 0) | (0, 0) |
|
|
|
// | 3 | | | (2, 0) | (3, 0) | (4, 0) |
|
|
|
// | 4 | | | | (1, 2) | (1, 3) |
|
|
|
// | 5 | | | | | (1, 5) |
|
|
|
// |---------------------------------------------------------|
|
|
|
// | Actual Ground Truth Values |
|
|
|
// | Position | (0, 0) | (1, 0) | (1, 1) | (1, 3) | (2, 3) |
|
|
|
// | Previous | (0, 0) | (0, 0) | (1, 0) | (1, 1) | (1, 3) |
|
|
|
//
|
|
|
// Note: this table organizes prediction targets by target ground truth index. Metrics are
|
|
|
// aggregated across points with the same prediction time bucket index, which is different.
|
|
|
// Each down-right diagonal from this table gives us points from a unique time bucket.
|
|
|
|
|
|
// Initialize expected prediction errors from the table above. The first time bucket corresponds
|
|
|
// to the long diagonal of the table, and subsequent time buckets step up-right from there.
|
|
|
const std::vector<std::vector<float>> expectedAlongTrajectoryErrors{{0, -1, -1, -1, -1},
|
|
|
{-1, -1, -3, -1},
|
|
|
{-1, -3, 2},
|
|
|
{-3, -2},
|
|
|
{-2}};
|
|
|
const std::vector<std::vector<float>> expectedOffTrajectoryErrors{{0, 0, 1, 0, 2},
|
|
|
{0, 1, 2, 0},
|
|
|
{1, 1, 3},
|
|
|
{1, 3},
|
|
|
{3}};
|
|
|
|
|
|
std::vector<GeneralPositionErrors> generalPositionErrors =
|
|
|
computeGeneralPositionErrors(groundTruthPoints, predictionPoints);
|
|
|
|
|
|
ASSERT_EQ(TEST_MAX_NUM_PREDICTIONS, generalPositionErrors.size());
|
|
|
for (size_t i = 0; i < generalPositionErrors.size(); ++i) {
|
|
|
SCOPED_TRACE(testing::Message() << "i = " << i);
|
|
|
EXPECT_FLOAT_EQ(average(expectedAlongTrajectoryErrors[i]),
|
|
|
generalPositionErrors[i].alongTrajectoryErrorMean);
|
|
|
EXPECT_FLOAT_EQ(standardDeviation(expectedAlongTrajectoryErrors[i]),
|
|
|
generalPositionErrors[i].alongTrajectoryErrorStd);
|
|
|
EXPECT_FLOAT_EQ(rmse(expectedOffTrajectoryErrors[i]),
|
|
|
generalPositionErrors[i].offTrajectoryRmse);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
TEST(ErrorComputationHelperTest, ComputePressureRmsesSimpleTest) {
|
|
|
// Generate ground truth points with pressures {0.0, 0.0, 0.0, 0.0, 0.5, 0.5, 0.5}.
|
|
|
// (We need TEST_MAX_NUM_PREDICTIONS + 2 to test all prediction time buckets.)
|
|
|
std::vector<GroundTruthPoint> groundTruthPoints =
|
|
|
generateConstantGroundTruthPoints(GroundTruthPoint{{.position = Eigen::Vector2f(0, 0),
|
|
|
.pressure = 0.0f},
|
|
|
.timestamp = TEST_INITIAL_TIMESTAMP},
|
|
|
/*numPoints=*/TEST_MAX_NUM_PREDICTIONS + 2);
|
|
|
for (size_t i = 4; i < groundTruthPoints.size(); ++i) {
|
|
|
groundTruthPoints[i].pressure = 0.5f;
|
|
|
}
|
|
|
|
|
|
std::vector<std::vector<PredictionPoint>> predictionPoints =
|
|
|
generateAllPredictionsByLinearExtrapolation(groundTruthPoints);
|
|
|
|
|
|
std::vector<float> pressureRmses = computePressureRmses(groundTruthPoints, predictionPoints);
|
|
|
|
|
|
ASSERT_EQ(TEST_MAX_NUM_PREDICTIONS, pressureRmses.size());
|
|
|
EXPECT_FLOAT_EQ(rmse(std::vector<float>{0.0f, 0.0f, -0.5f, 0.5f, 0.0f}), pressureRmses[0]);
|
|
|
EXPECT_FLOAT_EQ(rmse(std::vector<float>{0.0f, -0.5f, -0.5f, 1.0f}), pressureRmses[1]);
|
|
|
EXPECT_FLOAT_EQ(rmse(std::vector<float>{-0.5f, -0.5f, -0.5f}), pressureRmses[2]);
|
|
|
EXPECT_FLOAT_EQ(rmse(std::vector<float>{-0.5f, -0.5f}), pressureRmses[3]);
|
|
|
EXPECT_FLOAT_EQ(rmse(std::vector<float>{-0.5f}), pressureRmses[4]);
|
|
|
}
|
|
|
|
|
|
// --- MotionPredictorMetricsManager tests. ---
|
|
|
|
|
|
// Helper function that instantiates a MetricsManager with the given mock logged AtomFields. Takes
|
|
|
// vectors of ground truth and prediction points of the same length, and passes these points to the
|
|
|
// MetricsManager. The format of these vectors is expected to be:
|
|
|
// • groundTruthPoints: chronologically-ordered ground truth points, with at least 2 elements.
|
|
|
// • predictionPoints: the first index points to a vector of predictions corresponding to the
|
|
|
// source ground truth point with the same index.
|
|
|
// - The first element should be empty, because there are not expected to be predictions until
|
|
|
// we have received 2 ground truth points.
|
|
|
// - The last element may be empty, because there will be no future ground truth points to
|
|
|
// associate with those predictions (if not empty, it will be ignored).
|
|
|
// - To test all prediction buckets, there should be at least TEST_MAX_NUM_PREDICTIONS non-empty
|
|
|
// prediction sets (that is, excluding the first and last). Thus, groundTruthPoints and
|
|
|
// predictionPoints should have size at least TEST_MAX_NUM_PREDICTIONS + 2.
|
|
|
//
|
|
|
// The passed-in outAtomFields will contain the logged AtomFields when the function returns.
|
|
|
//
|
|
|
// This function returns void so that it can use test assertions.
|
|
|
void runMetricsManager(const std::vector<GroundTruthPoint>& groundTruthPoints,
|
|
|
const std::vector<std::vector<PredictionPoint>>& predictionPoints,
|
|
|
std::vector<AtomFields>& outAtomFields) {
|
|
|
MotionPredictorMetricsManager metricsManager(TEST_PREDICTION_INTERVAL_NANOS,
|
|
|
TEST_MAX_NUM_PREDICTIONS);
|
|
|
metricsManager.setMockLoggedAtomFields(&outAtomFields);
|
|
|
|
|
|
// Validate structure of groundTruthPoints and predictionPoints.
|
|
|
ASSERT_EQ(predictionPoints.size(), groundTruthPoints.size());
|
|
|
ASSERT_GE(groundTruthPoints.size(), 2u);
|
|
|
ASSERT_EQ(predictionPoints[0].size(), 0u);
|
|
|
for (size_t i = 1; i + 1 < predictionPoints.size(); ++i) {
|
|
|
SCOPED_TRACE(testing::Message() << "i = " << i);
|
|
|
ASSERT_EQ(predictionPoints[i].size(), TEST_MAX_NUM_PREDICTIONS);
|
|
|
}
|
|
|
|
|
|
// Pass ground truth points and predictions (for all except first and last ground truth).
|
|
|
for (size_t i = 0; i < groundTruthPoints.size(); ++i) {
|
|
|
metricsManager.onRecord(makeMotionEvent(groundTruthPoints[i]));
|
|
|
if ((i > 0) && (i + 1 < predictionPoints.size())) {
|
|
|
metricsManager.onPredict(makeMotionEvent(predictionPoints[i]));
|
|
|
}
|
|
|
}
|
|
|
// Send a stroke-end event to trigger the logging call.
|
|
|
metricsManager.onRecord(makeLiftMotionEvent());
|
|
|
}
|
|
|
|
|
|
// Vacuous test:
|
|
|
// • Input: no prediction data.
|
|
|
// • Expectation: no metrics should be logged.
|
|
|
TEST(MotionPredictorMetricsManagerTest, NoPredictions) {
|
|
|
std::vector<AtomFields> mockLoggedAtomFields;
|
|
|
MotionPredictorMetricsManager metricsManager(TEST_PREDICTION_INTERVAL_NANOS,
|
|
|
TEST_MAX_NUM_PREDICTIONS);
|
|
|
metricsManager.setMockLoggedAtomFields(&mockLoggedAtomFields);
|
|
|
|
|
|
metricsManager.onRecord(makeMotionEvent(
|
|
|
GroundTruthPoint{{.position = Eigen::Vector2f(0, 0), .pressure = 0}, .timestamp = 0}));
|
|
|
metricsManager.onRecord(makeLiftMotionEvent());
|
|
|
|
|
|
// Check that mockLoggedAtomFields is still empty (as it was initialized empty), ensuring that
|
|
|
// no metrics were logged.
|
|
|
EXPECT_EQ(0u, mockLoggedAtomFields.size());
|
|
|
}
|
|
|
|
|
|
// Perfect predictions test:
|
|
|
// • Input: constant input events, perfect predictions matching the input events.
|
|
|
// • Expectation: all error metrics should be zero, or NO_DATA_SENTINEL for "unreported" metrics.
|
|
|
// (For example, scale-invariant errors are only reported for the final time bucket.)
|
|
|
TEST(MotionPredictorMetricsManagerTest, ConstantGroundTruthPerfectPredictions) {
|
|
|
GroundTruthPoint groundTruthPoint{{.position = Eigen::Vector2f(10.0f, 20.0f), .pressure = 0.6f},
|
|
|
.timestamp = TEST_INITIAL_TIMESTAMP};
|
|
|
|
|
|
// Generate ground truth and prediction points as described by the runMetricsManager comment.
|
|
|
std::vector<GroundTruthPoint> groundTruthPoints;
|
|
|
std::vector<std::vector<PredictionPoint>> predictionPoints;
|
|
|
for (size_t i = 0; i < TEST_MAX_NUM_PREDICTIONS + 2; ++i) {
|
|
|
groundTruthPoints.push_back(groundTruthPoint);
|
|
|
predictionPoints.push_back(i > 0 ? generateConstantPredictions(groundTruthPoint)
|
|
|
: std::vector<PredictionPoint>{});
|
|
|
groundTruthPoint.timestamp += TEST_PREDICTION_INTERVAL_NANOS;
|
|
|
}
|
|
|
|
|
|
std::vector<AtomFields> atomFields;
|
|
|
runMetricsManager(groundTruthPoints, predictionPoints, atomFields);
|
|
|
|
|
|
ASSERT_EQ(TEST_MAX_NUM_PREDICTIONS, atomFields.size());
|
|
|
// Check that errors are all zero, or NO_DATA_SENTINEL for unreported metrics.
|
|
|
for (size_t i = 0; i < atomFields.size(); ++i) {
|
|
|
SCOPED_TRACE(testing::Message() << "i = " << i);
|
|
|
const AtomFields& atom = atomFields[i];
|
|
|
const nsecs_t deltaTimeBucketNanos = TEST_PREDICTION_INTERVAL_NANOS * (i + 1);
|
|
|
EXPECT_EQ(deltaTimeBucketNanos / NANOS_PER_MILLIS, atom.deltaTimeBucketMilliseconds);
|
|
|
// General errors: reported for every time bucket.
|
|
|
EXPECT_EQ(0, atom.alongTrajectoryErrorMeanMillipixels);
|
|
|
EXPECT_EQ(0, atom.alongTrajectoryErrorStdMillipixels);
|
|
|
EXPECT_EQ(0, atom.offTrajectoryRmseMillipixels);
|
|
|
EXPECT_EQ(0, atom.pressureRmseMilliunits);
|
|
|
// High-velocity errors: reported only for the last two time buckets.
|
|
|
// However, this data has zero velocity, so these metrics should all be NO_DATA_SENTINEL.
|
|
|
EXPECT_EQ(NO_DATA_SENTINEL, atom.highVelocityAlongTrajectoryRmse);
|
|
|
EXPECT_EQ(NO_DATA_SENTINEL, atom.highVelocityOffTrajectoryRmse);
|
|
|
// Scale-invariant errors: reported only for the last time bucket.
|
|
|
if (i + 1 == atomFields.size()) {
|
|
|
EXPECT_EQ(0, atom.scaleInvariantAlongTrajectoryRmse);
|
|
|
EXPECT_EQ(0, atom.scaleInvariantOffTrajectoryRmse);
|
|
|
} else {
|
|
|
EXPECT_EQ(NO_DATA_SENTINEL, atom.scaleInvariantAlongTrajectoryRmse);
|
|
|
EXPECT_EQ(NO_DATA_SENTINEL, atom.scaleInvariantOffTrajectoryRmse);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
TEST(MotionPredictorMetricsManagerTest, QuadraticPressureLinearPredictions) {
|
|
|
// Generate ground truth points.
|
|
|
//
|
|
|
// Ground truth pressures are a quadratically increasing function from some initial value.
|
|
|
const float initialPressure = 0.5f;
|
|
|
const float quadraticCoefficient = 0.01f;
|
|
|
std::vector<GroundTruthPoint> groundTruthPoints;
|
|
|
nsecs_t timestamp = TEST_INITIAL_TIMESTAMP;
|
|
|
// As described in the runMetricsManager comment, we should have TEST_MAX_NUM_PREDICTIONS + 2
|
|
|
// ground truth points.
|
|
|
for (size_t i = 0; i < TEST_MAX_NUM_PREDICTIONS + 2; ++i) {
|
|
|
const float pressure = initialPressure + quadraticCoefficient * static_cast<float>(i * i);
|
|
|
groundTruthPoints.push_back(
|
|
|
GroundTruthPoint{{.position = Eigen::Vector2f(0, 0), .pressure = pressure},
|
|
|
.timestamp = timestamp});
|
|
|
timestamp += TEST_PREDICTION_INTERVAL_NANOS;
|
|
|
}
|
|
|
|
|
|
// Note: the first index is the source ground truth index, and the second is the prediction
|
|
|
// target index.
|
|
|
std::vector<std::vector<PredictionPoint>> predictionPoints =
|
|
|
generateAllPredictionsByLinearExtrapolation(groundTruthPoints);
|
|
|
|
|
|
const std::vector<float> pressureErrors =
|
|
|
computePressureRmses(groundTruthPoints, predictionPoints);
|
|
|
|
|
|
// Run test.
|
|
|
std::vector<AtomFields> atomFields;
|
|
|
runMetricsManager(groundTruthPoints, predictionPoints, atomFields);
|
|
|
|
|
|
// Check logged metrics match expectations.
|
|
|
ASSERT_EQ(TEST_MAX_NUM_PREDICTIONS, atomFields.size());
|
|
|
for (size_t i = 0; i < atomFields.size(); ++i) {
|
|
|
SCOPED_TRACE(testing::Message() << "i = " << i);
|
|
|
const AtomFields& atom = atomFields[i];
|
|
|
// Check time bucket delta matches expectation based on index and prediction interval.
|
|
|
const nsecs_t deltaTimeBucketNanos = TEST_PREDICTION_INTERVAL_NANOS * (i + 1);
|
|
|
EXPECT_EQ(deltaTimeBucketNanos / NANOS_PER_MILLIS, atom.deltaTimeBucketMilliseconds);
|
|
|
// Check pressure error matches expectation.
|
|
|
EXPECT_NEAR(static_cast<int>(1000 * pressureErrors[i]), atom.pressureRmseMilliunits, 1);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
TEST(MotionPredictorMetricsManagerTest, QuadraticPositionLinearPredictionsGeneralErrors) {
|
|
|
// Generate ground truth points.
|
|
|
//
|
|
|
// Each component of the ground truth positions are an independent quadratically increasing
|
|
|
// function from some initial value.
|
|
|
const Eigen::Vector2f initialPosition(200, 300);
|
|
|
const Eigen::Vector2f quadraticCoefficients(-2, 3);
|
|
|
std::vector<GroundTruthPoint> groundTruthPoints;
|
|
|
nsecs_t timestamp = TEST_INITIAL_TIMESTAMP;
|
|
|
// As described in the runMetricsManager comment, we should have TEST_MAX_NUM_PREDICTIONS + 2
|
|
|
// ground truth points.
|
|
|
for (size_t i = 0; i < TEST_MAX_NUM_PREDICTIONS + 2; ++i) {
|
|
|
const Eigen::Vector2f position =
|
|
|
initialPosition + quadraticCoefficients * static_cast<float>(i * i);
|
|
|
groundTruthPoints.push_back(
|
|
|
GroundTruthPoint{{.position = position, .pressure = 0.5}, .timestamp = timestamp});
|
|
|
timestamp += TEST_PREDICTION_INTERVAL_NANOS;
|
|
|
}
|
|
|
|
|
|
// Note: the first index is the source ground truth index, and the second is the prediction
|
|
|
// target index.
|
|
|
std::vector<std::vector<PredictionPoint>> predictionPoints =
|
|
|
generateAllPredictionsByLinearExtrapolation(groundTruthPoints);
|
|
|
|
|
|
std::vector<GeneralPositionErrors> generalPositionErrors =
|
|
|
computeGeneralPositionErrors(groundTruthPoints, predictionPoints);
|
|
|
|
|
|
// Run test.
|
|
|
std::vector<AtomFields> atomFields;
|
|
|
runMetricsManager(groundTruthPoints, predictionPoints, atomFields);
|
|
|
|
|
|
// Check logged metrics match expectations.
|
|
|
ASSERT_EQ(TEST_MAX_NUM_PREDICTIONS, atomFields.size());
|
|
|
for (size_t i = 0; i < atomFields.size(); ++i) {
|
|
|
SCOPED_TRACE(testing::Message() << "i = " << i);
|
|
|
const AtomFields& atom = atomFields[i];
|
|
|
// Check time bucket delta matches expectation based on index and prediction interval.
|
|
|
const nsecs_t deltaTimeBucketNanos = TEST_PREDICTION_INTERVAL_NANOS * (i + 1);
|
|
|
EXPECT_EQ(deltaTimeBucketNanos / NANOS_PER_MILLIS, atom.deltaTimeBucketMilliseconds);
|
|
|
// Check general position errors match expectation.
|
|
|
EXPECT_NEAR(static_cast<int>(1000 * generalPositionErrors[i].alongTrajectoryErrorMean),
|
|
|
atom.alongTrajectoryErrorMeanMillipixels, 1);
|
|
|
EXPECT_NEAR(static_cast<int>(1000 * generalPositionErrors[i].alongTrajectoryErrorStd),
|
|
|
atom.alongTrajectoryErrorStdMillipixels, 1);
|
|
|
EXPECT_NEAR(static_cast<int>(1000 * generalPositionErrors[i].offTrajectoryRmse),
|
|
|
atom.offTrajectoryRmseMillipixels, 1);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// Counterclockwise regular octagonal section test:
|
|
|
// • Input – ground truth: constantly-spaced input events starting at a trajectory pointing exactly
|
|
|
// rightwards, and rotating by 45° counterclockwise after each input.
|
|
|
// • Input – predictions: simple linear extrapolations of previous two ground truth points.
|
|
|
//
|
|
|
// The code below uses the following terminology to distinguish references to ground truth events:
|
|
|
// • Source ground truth: the most recent ground truth point received at the time the prediction
|
|
|
// was made.
|
|
|
// • Target ground truth: the ground truth event that the prediction was attempting to match.
|
|
|
TEST(MotionPredictorMetricsManagerTest, CounterclockwiseOctagonGroundTruthLinearPredictions) {
|
|
|
// Select a stroke velocity that exceeds the high-velocity threshold of 1100 px/sec.
|
|
|
// For an input rate of 240 hz, 1100 px/sec * (1/240) sec/input ≈ 4.58 pixels per input.
|
|
|
const float strokeVelocity = 10; // pixels per input
|
|
|
|
|
|
// As described in the runMetricsManager comment, we should have TEST_MAX_NUM_PREDICTIONS + 2
|
|
|
// ground truth points.
|
|
|
std::vector<GroundTruthPoint> groundTruthPoints = generateCircularArcGroundTruthPoints(
|
|
|
/*initialPosition=*/Eigen::Vector2f(100, 100),
|
|
|
/*initialAngle=*/M_PI_2,
|
|
|
/*velocity=*/strokeVelocity,
|
|
|
/*turningAngle=*/-M_PI_4,
|
|
|
/*numPoints=*/TEST_MAX_NUM_PREDICTIONS + 2);
|
|
|
|
|
|
std::vector<std::vector<PredictionPoint>> predictionPoints =
|
|
|
generateAllPredictionsByLinearExtrapolation(groundTruthPoints);
|
|
|
|
|
|
std::vector<GeneralPositionErrors> generalPositionErrors =
|
|
|
computeGeneralPositionErrors(groundTruthPoints, predictionPoints);
|
|
|
|
|
|
// Run test.
|
|
|
std::vector<AtomFields> atomFields;
|
|
|
runMetricsManager(groundTruthPoints, predictionPoints, atomFields);
|
|
|
|
|
|
// Check logged metrics match expectations.
|
|
|
ASSERT_EQ(TEST_MAX_NUM_PREDICTIONS, atomFields.size());
|
|
|
for (size_t i = 0; i < atomFields.size(); ++i) {
|
|
|
SCOPED_TRACE(testing::Message() << "i = " << i);
|
|
|
const AtomFields& atom = atomFields[i];
|
|
|
const nsecs_t deltaTimeBucketNanos = TEST_PREDICTION_INTERVAL_NANOS * (i + 1);
|
|
|
EXPECT_EQ(deltaTimeBucketNanos / NANOS_PER_MILLIS, atom.deltaTimeBucketMilliseconds);
|
|
|
|
|
|
// General errors: reported for every time bucket.
|
|
|
EXPECT_NEAR(static_cast<int>(1000 * generalPositionErrors[i].alongTrajectoryErrorMean),
|
|
|
atom.alongTrajectoryErrorMeanMillipixels, 1);
|
|
|
// We allow for some floating point error in standard deviation (0.02 pixels).
|
|
|
EXPECT_NEAR(1000 * generalPositionErrors[i].alongTrajectoryErrorStd,
|
|
|
atom.alongTrajectoryErrorStdMillipixels, 20);
|
|
|
// All position errors are equal, so the standard deviation should be approximately zero.
|
|
|
EXPECT_NEAR(0, atom.alongTrajectoryErrorStdMillipixels, 20);
|
|
|
// Absolute value for RMSE, since it must be non-negative.
|
|
|
EXPECT_NEAR(static_cast<int>(1000 * generalPositionErrors[i].offTrajectoryRmse),
|
|
|
atom.offTrajectoryRmseMillipixels, 1);
|
|
|
|
|
|
// High-velocity errors: reported only for the last two time buckets.
|
|
|
//
|
|
|
// Since our input stroke velocity is chosen to be above the high-velocity threshold, all
|
|
|
// data contributes to high-velocity errors, and thus high-velocity errors should be equal
|
|
|
// to general errors (where reported).
|
|
|
//
|
|
|
// As above, use absolute value for RMSE, since it must be non-negative.
|
|
|
if (i + 2 >= atomFields.size()) {
|
|
|
EXPECT_NEAR(static_cast<int>(
|
|
|
1000 * std::abs(generalPositionErrors[i].alongTrajectoryErrorMean)),
|
|
|
atom.highVelocityAlongTrajectoryRmse, 1);
|
|
|
EXPECT_NEAR(static_cast<int>(1000 *
|
|
|
std::abs(generalPositionErrors[i].offTrajectoryRmse)),
|
|
|
atom.highVelocityOffTrajectoryRmse, 1);
|
|
|
} else {
|
|
|
EXPECT_EQ(NO_DATA_SENTINEL, atom.highVelocityAlongTrajectoryRmse);
|
|
|
EXPECT_EQ(NO_DATA_SENTINEL, atom.highVelocityOffTrajectoryRmse);
|
|
|
}
|
|
|
|
|
|
// Scale-invariant errors: reported only for the last time bucket, where the reported value
|
|
|
// is the aggregation across all time buckets.
|
|
|
//
|
|
|
// The MetricsManager stores mMaxNumPredictions recent ground truth segments. Our ground
|
|
|
// truth segments here all have a length of strokeVelocity, so we can convert general errors
|
|
|
// to scale-invariant errors by dividing by `strokeVelocty * TEST_MAX_NUM_PREDICTIONS`.
|
|
|
//
|
|
|
// As above, use absolute value for RMSE, since it must be non-negative.
|
|
|
if (i + 1 == atomFields.size()) {
|
|
|
const float pathLength = strokeVelocity * TEST_MAX_NUM_PREDICTIONS;
|
|
|
std::vector<float> alongTrajectoryAbsoluteErrors;
|
|
|
std::vector<float> offTrajectoryAbsoluteErrors;
|
|
|
for (size_t j = 0; j < TEST_MAX_NUM_PREDICTIONS; ++j) {
|
|
|
alongTrajectoryAbsoluteErrors.push_back(
|
|
|
std::abs(generalPositionErrors[j].alongTrajectoryErrorMean));
|
|
|
offTrajectoryAbsoluteErrors.push_back(
|
|
|
std::abs(generalPositionErrors[j].offTrajectoryRmse));
|
|
|
}
|
|
|
EXPECT_NEAR(static_cast<int>(1000 * average(alongTrajectoryAbsoluteErrors) /
|
|
|
pathLength),
|
|
|
atom.scaleInvariantAlongTrajectoryRmse, 1);
|
|
|
EXPECT_NEAR(static_cast<int>(1000 * average(offTrajectoryAbsoluteErrors) / pathLength),
|
|
|
atom.scaleInvariantOffTrajectoryRmse, 1);
|
|
|
} else {
|
|
|
EXPECT_EQ(NO_DATA_SENTINEL, atom.scaleInvariantAlongTrajectoryRmse);
|
|
|
EXPECT_EQ(NO_DATA_SENTINEL, atom.scaleInvariantOffTrajectoryRmse);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
} // namespace
|
|
|
} // namespace android
|
