blob: 9da2e2a3150b5302fb6291a8e7708f4d1bb49df3 [file] [log] [blame]
Siarhei Vishniakoud4b607e2017-06-13 12:21:59 +01001/*
2 * Copyright (C) 2017 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "VelocityTracker_test"
18
Siarhei Vishniakouf7e2d3e2018-09-07 16:38:18 -070019#include <array>
Siarhei Vishniakoud4b607e2017-06-13 12:21:59 +010020#include <math.h>
21
22#include <android-base/stringprintf.h>
23#include <gtest/gtest.h>
24#include <input/VelocityTracker.h>
25
26using android::base::StringPrintf;
27
28namespace android {
29
30constexpr int32_t DEFAULT_POINTER_ID = 0; // pointer ID used for manually defined tests
31
32// velocity must be in the range (1-tol)*EV <= velocity <= (1+tol)*EV
33// here EV = expected value, tol = VELOCITY_TOLERANCE
34constexpr float VELOCITY_TOLERANCE = 0.2;
35
Siarhei Vishniakouf7e2d3e2018-09-07 16:38:18 -070036// estimate coefficients must be within 0.001% of the target value
37constexpr float COEFFICIENT_TOLERANCE = 0.00001;
38
Siarhei Vishniakoud4b607e2017-06-13 12:21:59 +010039// --- VelocityTrackerTest ---
40class VelocityTrackerTest : public testing::Test { };
41
Siarhei Vishniakouf7e2d3e2018-09-07 16:38:18 -070042/*
43 * Similar to EXPECT_NEAR, but ensures that the difference between the two float values
44 * is at most a certain fraction of the target value.
45 * If fraction is zero, require exact match.
46 */
47static void EXPECT_NEAR_BY_FRACTION(float actual, float target, float fraction) {
48 float tolerance = fabsf(target * fraction);
Siarhei Vishniakoud4b607e2017-06-13 12:21:59 +010049
Siarhei Vishniakouf7e2d3e2018-09-07 16:38:18 -070050 if (target == 0 && fraction != 0) {
51 // If target is zero, this would force actual == target, which is too harsh.
52 // Relax this requirement a little. The value is determined empirically from the
53 // coefficients computed by the quadratic least squares algorithms.
54 tolerance = 1E-6;
Siarhei Vishniakoud4b607e2017-06-13 12:21:59 +010055 }
Siarhei Vishniakouf7e2d3e2018-09-07 16:38:18 -070056 EXPECT_NEAR(actual, target, tolerance);
57}
58
59static void checkVelocity(float Vactual, float Vtarget) {
60 EXPECT_NEAR_BY_FRACTION(Vactual, Vtarget, VELOCITY_TOLERANCE);
61}
62
63static void checkCoefficient(float actual, float target) {
64 EXPECT_NEAR_BY_FRACTION(actual, target, COEFFICIENT_TOLERANCE);
Siarhei Vishniakoud4b607e2017-06-13 12:21:59 +010065}
66
67void failWithMessage(std::string message) {
68 FAIL() << message; // cannot do this directly from a non-void function
69}
70
71struct Position {
72 nsecs_t time;
73 float x;
74 float y;
75};
76
77
78MotionEvent* createSimpleMotionEvent(const Position* positions, size_t numSamples) {
79 /**
80 * Only populate the basic fields of a MotionEvent, such as time and a single axis
81 * Designed for use with manually-defined tests.
82 * Create a new MotionEvent on the heap, caller responsible for destroying the object.
83 */
84 if (numSamples < 1) {
85 failWithMessage(StringPrintf("Need at least 1 sample to create a MotionEvent."
86 " Received numSamples=%zu", numSamples));
87 }
88
89 MotionEvent* event = new MotionEvent();
90 PointerCoords coords;
91 PointerProperties properties[1];
92
93 properties[0].id = DEFAULT_POINTER_ID;
94 properties[0].toolType = AMOTION_EVENT_TOOL_TYPE_FINGER;
95
96 // First sample added separately with initialize
97 coords.setAxisValue(AMOTION_EVENT_AXIS_X, positions[0].x);
98 coords.setAxisValue(AMOTION_EVENT_AXIS_Y, positions[0].y);
99 event->initialize(0, AINPUT_SOURCE_TOUCHSCREEN, AMOTION_EVENT_ACTION_MOVE,
100 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, positions[0].time, 1, properties, &coords);
101
102 for (size_t i = 1; i < numSamples; i++) {
103 coords.setAxisValue(AMOTION_EVENT_AXIS_X, positions[i].x);
104 coords.setAxisValue(AMOTION_EVENT_AXIS_Y, positions[i].y);
105 event->addSample(positions[i].time, &coords);
106 }
107 return event;
108}
109
110static void computeAndCheckVelocity(const Position* positions, size_t numSamples,
111 int32_t axis, float targetVelocity) {
112 VelocityTracker vt(nullptr);
113 float Vx, Vy;
114
115 MotionEvent* event = createSimpleMotionEvent(positions, numSamples);
116 vt.addMovement(event);
117
118 vt.getVelocity(DEFAULT_POINTER_ID, &Vx, &Vy);
119
120 switch (axis) {
121 case AMOTION_EVENT_AXIS_X:
122 checkVelocity(Vx, targetVelocity);
123 break;
124 case AMOTION_EVENT_AXIS_Y:
125 checkVelocity(Vy, targetVelocity);
126 break;
127 default:
128 FAIL() << "Axis must be either AMOTION_EVENT_AXIS_X or AMOTION_EVENT_AXIS_Y";
129 }
130 delete event;
131}
132
Siarhei Vishniakouf7e2d3e2018-09-07 16:38:18 -0700133static void computeAndCheckQuadraticEstimate(const Position* positions, size_t numSamples,
134 const std::array<float, 3>& coefficients) {
135 VelocityTracker vt("lsq2");
136 MotionEvent* event = createSimpleMotionEvent(positions, numSamples);
137 vt.addMovement(event);
138 VelocityTracker::Estimator estimator;
139 EXPECT_TRUE(vt.getEstimator(0, &estimator));
140 for (size_t i = 0; i< coefficients.size(); i++) {
141 checkCoefficient(estimator.xCoeff[i], coefficients[i]);
142 checkCoefficient(estimator.yCoeff[i], coefficients[i]);
143 }
144}
145
Siarhei Vishniakoud4b607e2017-06-13 12:21:59 +0100146/*
147 * ================== VelocityTracker tests generated manually =====================================
148 */
149 // @todo Currently disabled, enable when switching away from lsq2 VelocityTrackerStrategy
150TEST_F(VelocityTrackerTest, DISABLED_ThreePointsPositiveVelocityTest) {
151 // Same coordinate is reported 2 times in a row
152 // It is difficult to determine the correct answer here, but at least the direction
153 // of the reported velocity should be positive.
154 Position values[] = {
155 { 0, 273, NAN },
156 { 12585000, 293, NAN },
157 { 14730000, 293, NAN },
158 };
159 size_t count = sizeof(values) / sizeof(Position);
160 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_X, 1600);
161}
162
163TEST_F(VelocityTrackerTest, ThreePointsZeroVelocityTest) {
164 // Same coordinate is reported 3 times in a row
165 Position values[] = {
166 { 0, 293, NAN },
167 { 6132000, 293, NAN },
168 { 11283000, 293, NAN },
169 };
170 size_t count = sizeof(values) / sizeof(Position);
171 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_X, 0);
172}
173
174TEST_F(VelocityTrackerTest, ThreePointsLinearVelocityTest) {
175 // Fixed velocity at 5 points per 10 milliseconds
176 Position values[] = {
177 { 0, 0, NAN },
178 { 10000000, 5, NAN },
179 { 20000000, 10, NAN },
180 };
181 size_t count = sizeof(values) / sizeof(Position);
182 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_X, 500);
183}
184
185
186/**
187 * ================== VelocityTracker tests generated by recording real events =====================
188 *
189 * To add a test, record the input coordinates and event times to all calls
190 * to void VelocityTracker::addMovement(const MotionEvent* event).
191 * Also record all calls to VelocityTracker::clear().
192 * Finally, record the output of VelocityTracker::getVelocity(...)
193 * This will give you the necessary data to create a new test.
194 */
195
196// --------------- Recorded by hand on swordfish ---------------------------------------------------
197// @todo Currently disabled, enable when switching away from lsq2 VelocityTrackerStrategy
198TEST_F(VelocityTrackerTest, DISABLED_SwordfishFlingDown) {
199 // Recording of a fling on Swordfish that could cause a fling in the wrong direction
200 Position values[] = {
201 { 0, 271, 96 },
202 { 16071042, 269.786346, 106.922775 },
203 { 35648403, 267.983063, 156.660034 },
204 { 52313925, 262.638397, 220.339081 },
205 { 68976522, 266.138824, 331.581116 },
206 { 85639375, 274.79245, 428.113159 },
207 { 96948871, 274.79245, 428.113159 },
208 };
209 size_t count = sizeof(values) / sizeof(Position);
210 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_X, 623.577637);
211 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, 8523.348633);
212}
213
214// --------------- Recorded by hand on sailfish, generated by a script -----------------------------
215// For some of these tests, the X-direction velocity checking has been removed, because the lsq2
216// and the impulse VelocityTrackerStrategies did not agree within 20%.
217// Since the flings were recorded in the Y-direction, the intentional user action should only
218// be relevant for the Y axis.
219// There have been also cases where lsq2 and impulse disagreed more than 20% in the Y-direction.
220// Those recordings have been discarded because we didn't feel one strategy's interpretation was
221// more correct than another's but didn't want to increase the tolerance for the entire test suite.
222//
223// There are 18 tests total below: 9 in the positive Y direction and 9 in the opposite.
224// The recordings were loosely binned into 3 categories - slow, faster, and fast, which roughly
225// characterizes the velocity of the finger motion.
226// These can be treated approximately as:
227// slow - less than 1 page gets scrolled
228// faster - more than 1 page gets scrolled, but less than 3
229// fast - entire list is scrolled (fling is done as hard as possible)
230
231TEST_F(VelocityTrackerTest, SailfishFlingUpSlow1) {
232 // Sailfish - fling up - slow - 1
233 Position values[] = {
234 { 235089067457000, 528.00, 983.00 },
235 { 235089084684000, 527.00, 981.00 },
236 { 235089093349000, 527.00, 977.00 },
237 { 235089095677625, 527.00, 975.93 },
238 { 235089101859000, 527.00, 970.00 },
239 { 235089110378000, 528.00, 960.00 },
240 { 235089112497111, 528.25, 957.51 },
241 { 235089118760000, 531.00, 946.00 },
242 { 235089126686000, 535.00, 931.00 },
243 { 235089129316820, 536.33, 926.02 },
244 { 235089135199000, 540.00, 914.00 },
245 { 235089144297000, 546.00, 896.00 },
246 { 235089146136443, 547.21, 892.36 },
247 { 235089152923000, 553.00, 877.00 },
248 { 235089160784000, 559.00, 851.00 },
249 { 235089162955851, 560.66, 843.82 },
250 };
251 size_t count = sizeof(values) / sizeof(Position);
252 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_X, 872.794617); // impulse
253 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_X, 951.698181); // lsq2
254 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, -3604.819336); // impulse
255 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, -3044.966064); // lsq2
256}
257
258
259TEST_F(VelocityTrackerTest, SailfishFlingUpSlow2) {
260 // Sailfish - fling up - slow - 2
261 Position values[] = {
262 { 235110560704000, 522.00, 1107.00 },
263 { 235110575764000, 522.00, 1107.00 },
264 { 235110584385000, 522.00, 1107.00 },
265 { 235110588421179, 521.52, 1106.52 },
266 { 235110592830000, 521.00, 1106.00 },
267 { 235110601385000, 520.00, 1104.00 },
268 { 235110605088160, 519.14, 1102.27 },
269 { 235110609952000, 518.00, 1100.00 },
270 { 235110618353000, 517.00, 1093.00 },
271 { 235110621755146, 516.60, 1090.17 },
272 { 235110627010000, 517.00, 1081.00 },
273 { 235110634785000, 518.00, 1063.00 },
274 { 235110638422450, 518.87, 1052.58 },
275 { 235110643161000, 520.00, 1039.00 },
276 { 235110651767000, 524.00, 1011.00 },
277 { 235110655089581, 525.54, 1000.19 },
278 { 235110660368000, 530.00, 980.00 },
279 };
280 size_t count = sizeof(values) / sizeof(Position);
281 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, -4096.583008); // impulse
282 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, -3455.094238); // lsq2
283}
284
285
286TEST_F(VelocityTrackerTest, SailfishFlingUpSlow3) {
287 // Sailfish - fling up - slow - 3
288 Position values[] = {
289 { 792536237000, 580.00, 1317.00 },
290 { 792541538987, 580.63, 1311.94 },
291 { 792544613000, 581.00, 1309.00 },
292 { 792552301000, 583.00, 1295.00 },
293 { 792558362309, 585.13, 1282.92 },
294 { 792560828000, 586.00, 1278.00 },
295 { 792569446000, 589.00, 1256.00 },
296 { 792575185095, 591.54, 1241.41 },
297 { 792578491000, 593.00, 1233.00 },
298 { 792587044000, 597.00, 1211.00 },
299 { 792592008172, 600.28, 1195.92 },
300 { 792594616000, 602.00, 1188.00 },
301 { 792603129000, 607.00, 1167.00 },
302 { 792608831290, 609.48, 1155.83 },
303 { 792612321000, 611.00, 1149.00 },
304 { 792620768000, 615.00, 1131.00 },
305 { 792625653873, 617.32, 1121.73 },
306 { 792629200000, 619.00, 1115.00 },
307 };
308 size_t count = sizeof(values) / sizeof(Position);
309 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_X, 574.33429); // impulse
310 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_X, 617.40564); // lsq2
311 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, -2361.982666); // impulse
312 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, -2500.055664); // lsq2
313}
314
315
316TEST_F(VelocityTrackerTest, SailfishFlingUpFaster1) {
317 // Sailfish - fling up - faster - 1
318 Position values[] = {
319 { 235160420675000, 610.00, 1042.00 },
320 { 235160428220000, 609.00, 1026.00 },
321 { 235160436544000, 609.00, 1024.00 },
322 { 235160441852394, 609.64, 1020.82 },
323 { 235160444878000, 610.00, 1019.00 },
324 { 235160452673000, 613.00, 1006.00 },
325 { 235160458519743, 617.18, 992.06 },
326 { 235160461061000, 619.00, 986.00 },
327 { 235160469798000, 627.00, 960.00 },
328 { 235160475186713, 632.22, 943.02 },
329 { 235160478051000, 635.00, 934.00 },
330 { 235160486489000, 644.00, 906.00 },
331 { 235160491853697, 649.56, 890.56 },
332 { 235160495177000, 653.00, 881.00 },
333 { 235160504148000, 662.00, 858.00 },
334 { 235160509231495, 666.81, 845.37 },
335 { 235160512603000, 670.00, 837.00 },
336 { 235160520366000, 679.00, 814.00 },
337 };
338 size_t count = sizeof(values) / sizeof(Position);
339 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_X, 1274.141724); // impulse
340 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_X, 1438.53186); // lsq2
341 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, -3877.35498); // impulse
342 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, -3695.859619); // lsq2
343}
344
345
346TEST_F(VelocityTrackerTest, SailfishFlingUpFaster2) {
347 // Sailfish - fling up - faster - 2
348 Position values[] = {
349 { 847153808000, 576.00, 1264.00 },
350 { 847171174000, 576.00, 1262.00 },
351 { 847179640000, 576.00, 1257.00 },
352 { 847185187540, 577.41, 1249.22 },
353 { 847187487000, 578.00, 1246.00 },
354 { 847195710000, 581.00, 1227.00 },
355 { 847202027059, 583.93, 1209.40 },
356 { 847204324000, 585.00, 1203.00 },
357 { 847212672000, 590.00, 1176.00 },
358 { 847218861395, 594.36, 1157.11 },
359 { 847221190000, 596.00, 1150.00 },
360 { 847230484000, 602.00, 1124.00 },
361 { 847235701400, 607.56, 1103.83 },
362 { 847237986000, 610.00, 1095.00 },
363 };
364 size_t count = sizeof(values) / sizeof(Position);
365 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, -4280.07959); // impulse
366 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, -4241.004395); // lsq2
367}
368
369
370TEST_F(VelocityTrackerTest, SailfishFlingUpFaster3) {
371 // Sailfish - fling up - faster - 3
372 Position values[] = {
373 { 235200532789000, 507.00, 1084.00 },
374 { 235200549221000, 507.00, 1083.00 },
375 { 235200557841000, 507.00, 1081.00 },
376 { 235200558051189, 507.00, 1080.95 },
377 { 235200566314000, 507.00, 1078.00 },
378 { 235200574876586, 508.97, 1070.12 },
379 { 235200575006000, 509.00, 1070.00 },
380 { 235200582900000, 514.00, 1054.00 },
381 { 235200591276000, 525.00, 1023.00 },
382 { 235200591701829, 525.56, 1021.42 },
383 { 235200600064000, 542.00, 976.00 },
384 { 235200608519000, 563.00, 911.00 },
385 { 235200608527086, 563.02, 910.94 },
386 { 235200616933000, 590.00, 844.00 },
387 };
388 size_t count = sizeof(values) / sizeof(Position);
389 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, -8715.686523); // impulse
390 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, -7639.026367); // lsq2
391}
392
393
394TEST_F(VelocityTrackerTest, SailfishFlingUpFast1) {
395 // Sailfish - fling up - fast - 1
396 Position values[] = {
397 { 920922149000, 561.00, 1412.00 },
398 { 920930185000, 559.00, 1377.00 },
399 { 920930262463, 558.98, 1376.66 },
400 { 920938547000, 559.00, 1371.00 },
401 { 920947096857, 562.91, 1342.68 },
402 { 920947302000, 563.00, 1342.00 },
403 { 920955502000, 577.00, 1272.00 },
404 { 920963931021, 596.87, 1190.54 },
405 { 920963987000, 597.00, 1190.00 },
406 { 920972530000, 631.00, 1093.00 },
407 { 920980765511, 671.31, 994.68 },
408 { 920980906000, 672.00, 993.00 },
409 { 920989261000, 715.00, 903.00 },
410 };
411 size_t count = sizeof(values) / sizeof(Position);
412 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_X, 5670.329102); // impulse
413 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_X, 5991.866699); // lsq2
414 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, -13021.101562); // impulse
415 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, -15093.995117); // lsq2
416}
417
418
419TEST_F(VelocityTrackerTest, SailfishFlingUpFast2) {
420 // Sailfish - fling up - fast - 2
421 Position values[] = {
422 { 235247153233000, 518.00, 1168.00 },
423 { 235247170452000, 517.00, 1167.00 },
424 { 235247178908000, 515.00, 1159.00 },
425 { 235247179556213, 514.85, 1158.39 },
426 { 235247186821000, 515.00, 1125.00 },
427 { 235247195265000, 521.00, 1051.00 },
428 { 235247196389476, 521.80, 1041.15 },
429 { 235247203649000, 538.00, 932.00 },
430 { 235247212253000, 571.00, 794.00 },
431 { 235247213222491, 574.72, 778.45 },
432 { 235247220736000, 620.00, 641.00 },
433 };
434 size_t count = sizeof(values) / sizeof(Position);
435 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, -20286.958984); // impulse
436 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, -20494.587891); // lsq2
437}
438
439
440TEST_F(VelocityTrackerTest, SailfishFlingUpFast3) {
441 // Sailfish - fling up - fast - 3
442 Position values[] = {
443 { 235302568736000, 529.00, 1167.00 },
444 { 235302576644000, 523.00, 1140.00 },
445 { 235302579395063, 520.91, 1130.61 },
446 { 235302585140000, 522.00, 1130.00 },
447 { 235302593615000, 527.00, 1065.00 },
448 { 235302596207444, 528.53, 1045.12 },
449 { 235302602102000, 559.00, 872.00 },
450 { 235302610545000, 652.00, 605.00 },
451 { 235302613019881, 679.26, 526.73 },
452 };
453 size_t count = sizeof(values) / sizeof(Position);
454 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, -39295.941406); // impulse
455 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, -36461.421875); // lsq2
456}
457
458
459TEST_F(VelocityTrackerTest, SailfishFlingDownSlow1) {
460 // Sailfish - fling down - slow - 1
461 Position values[] = {
462 { 235655749552755, 582.00, 432.49 },
463 { 235655750638000, 582.00, 433.00 },
464 { 235655758865000, 582.00, 440.00 },
465 { 235655766221523, 581.16, 448.43 },
466 { 235655767594000, 581.00, 450.00 },
467 { 235655776044000, 580.00, 462.00 },
468 { 235655782890696, 579.18, 474.35 },
469 { 235655784360000, 579.00, 477.00 },
470 { 235655792795000, 578.00, 496.00 },
471 { 235655799559531, 576.27, 515.04 },
472 { 235655800612000, 576.00, 518.00 },
473 { 235655809535000, 574.00, 542.00 },
474 { 235655816988015, 572.17, 564.86 },
475 { 235655817685000, 572.00, 567.00 },
476 { 235655825981000, 569.00, 595.00 },
477 { 235655833808653, 566.26, 620.60 },
478 { 235655834541000, 566.00, 623.00 },
479 { 235655842893000, 563.00, 649.00 },
480 };
481 size_t count = sizeof(values) / sizeof(Position);
482 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_X, -419.749695); // impulse
483 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_X, -398.303894); // lsq2
484 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, 3309.016357); // impulse
485 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, 3969.099854); // lsq2
486}
487
488
489TEST_F(VelocityTrackerTest, SailfishFlingDownSlow2) {
490 // Sailfish - fling down - slow - 2
491 Position values[] = {
492 { 235671152083370, 485.24, 558.28 },
493 { 235671154126000, 485.00, 559.00 },
494 { 235671162497000, 484.00, 566.00 },
495 { 235671168750511, 483.27, 573.29 },
496 { 235671171071000, 483.00, 576.00 },
497 { 235671179390000, 482.00, 588.00 },
498 { 235671185417210, 481.31, 598.98 },
499 { 235671188173000, 481.00, 604.00 },
500 { 235671196371000, 480.00, 624.00 },
501 { 235671202084196, 479.27, 639.98 },
502 { 235671204235000, 479.00, 646.00 },
503 { 235671212554000, 478.00, 673.00 },
504 { 235671219471011, 476.39, 697.12 },
505 { 235671221159000, 476.00, 703.00 },
506 { 235671229592000, 474.00, 734.00 },
507 { 235671236281462, 472.43, 758.38 },
508 { 235671238098000, 472.00, 765.00 },
509 { 235671246532000, 470.00, 799.00 },
510 };
511 size_t count = sizeof(values) / sizeof(Position);
512 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_X, -262.80426); // impulse
513 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_X, -243.665344); // lsq2
514 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, 4215.682129); // impulse
515 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, 4587.986816); // lsq2
516}
517
518
519TEST_F(VelocityTrackerTest, SailfishFlingDownSlow3) {
520 // Sailfish - fling down - slow - 3
521 Position values[] = {
522 { 170983201000, 557.00, 533.00 },
523 { 171000668000, 556.00, 534.00 },
524 { 171007359750, 554.73, 535.27 },
525 { 171011197000, 554.00, 536.00 },
526 { 171017660000, 552.00, 540.00 },
527 { 171024201831, 549.97, 544.73 },
528 { 171027333000, 549.00, 547.00 },
529 { 171034603000, 545.00, 557.00 },
530 { 171041043371, 541.98, 567.55 },
531 { 171043147000, 541.00, 571.00 },
532 { 171051052000, 536.00, 586.00 },
533 };
534 size_t count = sizeof(values) / sizeof(Position);
535 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_X, -723.413513); // impulse
536 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_X, -651.038452); // lsq2
537 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, 2091.502441); // impulse
538 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, 1934.517456); // lsq2
539}
540
541
542TEST_F(VelocityTrackerTest, SailfishFlingDownFaster1) {
543 // Sailfish - fling down - faster - 1
544 Position values[] = {
545 { 235695280333000, 558.00, 451.00 },
546 { 235695283971237, 558.43, 454.45 },
547 { 235695289038000, 559.00, 462.00 },
548 { 235695297388000, 561.00, 478.00 },
549 { 235695300638465, 561.83, 486.25 },
550 { 235695305265000, 563.00, 498.00 },
551 { 235695313591000, 564.00, 521.00 },
552 { 235695317305492, 564.43, 532.68 },
553 { 235695322181000, 565.00, 548.00 },
554 { 235695330709000, 565.00, 577.00 },
555 { 235695333972227, 565.00, 588.10 },
556 { 235695339250000, 565.00, 609.00 },
557 { 235695347839000, 565.00, 642.00 },
558 { 235695351313257, 565.00, 656.18 },
559 { 235695356412000, 565.00, 677.00 },
560 { 235695364899000, 563.00, 710.00 },
561 { 235695368118682, 562.24, 722.52 },
562 { 235695373403000, 564.00, 744.00 },
563 };
564 size_t count = sizeof(values) / sizeof(Position);
565 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, 4254.639648); // impulse
566 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, 4698.415039); // lsq2
567}
568
569
570TEST_F(VelocityTrackerTest, SailfishFlingDownFaster2) {
571 // Sailfish - fling down - faster - 2
572 Position values[] = {
573 { 235709624766000, 535.00, 579.00 },
574 { 235709642256000, 534.00, 580.00 },
575 { 235709643350278, 533.94, 580.06 },
576 { 235709650760000, 532.00, 584.00 },
577 { 235709658615000, 530.00, 593.00 },
578 { 235709660170495, 529.60, 594.78 },
579 { 235709667095000, 527.00, 606.00 },
580 { 235709675616000, 524.00, 628.00 },
581 { 235709676983261, 523.52, 631.53 },
582 { 235709684289000, 521.00, 652.00 },
583 { 235709692763000, 518.00, 682.00 },
584 { 235709693804993, 517.63, 685.69 },
585 { 235709701438000, 515.00, 709.00 },
586 { 235709709830000, 512.00, 739.00 },
587 { 235709710626776, 511.72, 741.85 },
588 };
589 size_t count = sizeof(values) / sizeof(Position);
590 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_X, -430.440247); // impulse
591 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_X, -447.600311); // lsq2
592 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, 3953.859375); // impulse
593 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, 4316.155273); // lsq2
594}
595
596
597TEST_F(VelocityTrackerTest, SailfishFlingDownFaster3) {
598 // Sailfish - fling down - faster - 3
599 Position values[] = {
600 { 235727628927000, 540.00, 440.00 },
601 { 235727636810000, 537.00, 454.00 },
602 { 235727646176000, 536.00, 454.00 },
603 { 235727653586628, 535.12, 456.65 },
604 { 235727654557000, 535.00, 457.00 },
605 { 235727663024000, 534.00, 465.00 },
606 { 235727670410103, 533.04, 479.45 },
607 { 235727670691000, 533.00, 480.00 },
608 { 235727679255000, 531.00, 501.00 },
609 { 235727687233704, 529.09, 526.73 },
610 { 235727687628000, 529.00, 528.00 },
611 { 235727696113000, 526.00, 558.00 },
612 { 235727704057546, 523.18, 588.98 },
613 { 235727704576000, 523.00, 591.00 },
614 { 235727713099000, 520.00, 626.00 },
615 { 235727720880776, 516.33, 655.36 },
616 { 235727721580000, 516.00, 658.00 },
617 };
618 size_t count = sizeof(values) / sizeof(Position);
619 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, 4484.617676); // impulse
620 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, 4927.92627); // lsq2
621}
622
623
624TEST_F(VelocityTrackerTest, SailfishFlingDownFast1) {
625 // Sailfish - fling down - fast - 1
626 Position values[] = {
627 { 235762352849000, 467.00, 286.00 },
628 { 235762360250000, 443.00, 344.00 },
629 { 235762362787412, 434.77, 363.89 },
630 { 235762368807000, 438.00, 359.00 },
631 { 235762377220000, 425.00, 423.00 },
632 { 235762379608561, 421.31, 441.17 },
633 { 235762385698000, 412.00, 528.00 },
634 { 235762394133000, 406.00, 648.00 },
635 { 235762396429369, 404.37, 680.67 },
636 };
637 size_t count = sizeof(values) / sizeof(Position);
638 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, 19084.931641); // impulse
639 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, 16064.685547); // lsq2
640}
641
642
643TEST_F(VelocityTrackerTest, SailfishFlingDownFast2) {
644 // Sailfish - fling down - fast - 2
645 Position values[] = {
646 { 235772487188000, 576.00, 204.00 },
647 { 235772495159000, 553.00, 236.00 },
648 { 235772503568000, 551.00, 240.00 },
649 { 235772508192247, 545.55, 254.17 },
650 { 235772512051000, 541.00, 266.00 },
651 { 235772520794000, 520.00, 337.00 },
652 { 235772525015263, 508.92, 394.43 },
653 { 235772529174000, 498.00, 451.00 },
654 { 235772537635000, 484.00, 589.00 },
655 };
656 size_t count = sizeof(values) / sizeof(Position);
657 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, 18660.048828); // impulse
658 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, 16918.439453); // lsq2
659}
660
661
662TEST_F(VelocityTrackerTest, SailfishFlingDownFast3) {
663 // Sailfish - fling down - fast - 3
664 Position values[] = {
665 { 507650295000, 628.00, 233.00 },
666 { 507658234000, 605.00, 269.00 },
667 { 507666784000, 601.00, 274.00 },
668 { 507669660483, 599.65, 275.68 },
669 { 507675427000, 582.00, 308.00 },
670 { 507683740000, 541.00, 404.00 },
671 { 507686506238, 527.36, 435.95 },
672 { 507692220000, 487.00, 581.00 },
673 { 507700707000, 454.00, 792.00 },
674 { 507703352649, 443.71, 857.77 },
675 };
676 size_t count = sizeof(values) / sizeof(Position);
677 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_X, -6772.508301); // impulse
678 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_X, -6388.48877); // lsq2
679 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, 29765.908203); // impulse
680 computeAndCheckVelocity(values, count, AMOTION_EVENT_AXIS_Y, 28354.796875); // lsq2
681}
682
Siarhei Vishniakouf7e2d3e2018-09-07 16:38:18 -0700683/*
684 * Special care must be taken when constructing tests for LeastSquaresVelocityTrackerStrategy
685 * getEstimator function. In particular:
686 * - inside the function, time gets converted from nanoseconds to seconds
687 * before being used in the fit.
688 * - any values that are older than 100 ms are being discarded.
689 * - the newest time gets subtracted from all of the other times before being used in the fit.
690 * So these tests have to be designed with those limitations in mind.
691 *
692 * General approach for the tests below:
693 * We only used timestamps in milliseconds, 0 ms, 1 ms, and 2 ms, to be sure that
694 * we are well within the HORIZON range.
695 * When specifying the expected values of the coefficients, we treat the x values as if
696 * they were in ms. Then, to adjust for the time units, the coefficients get progressively
697 * multiplied by powers of 1E3.
698 * For example:
699 * data: t(ms), x
700 * 1 ms, 1
701 * 2 ms, 4
702 * 3 ms, 9
703 * The coefficients are (0, 0, 1).
704 * In the test, we would convert these coefficients to (0*(1E3)^0, 0*(1E3)^1, 1*(1E3)^2).
705 */
706TEST_F(VelocityTrackerTest, LeastSquaresVelocityTrackerStrategyEstimator_Constant) {
707 Position values[] = {
708 { 0000000, 1, 1 }, // 0 s
709 { 1000000, 1, 1 }, // 0.001 s
710 { 2000000, 1, 1 }, // 0.002 s
711 };
712 // The data used for the fit will be as follows:
713 // time(s), position
714 // -0.002, 1
715 // -0.001, 1
716 // -0.000, 1
717 size_t count = sizeof(values) / sizeof(Position);
718 computeAndCheckQuadraticEstimate(values, count, std::array<float, 3>({1, 0, 0}));
719}
720
721/*
722 * Straight line y = x :: the constant and quadratic coefficients are zero.
723 */
724TEST_F(VelocityTrackerTest, LeastSquaresVelocityTrackerStrategyEstimator_Linear) {
725 Position values[] = {
726 { 0000000, -2, -2 },
727 { 1000000, -1, -1 },
728 { 2000000, -0, -0 },
729 };
730 // The data used for the fit will be as follows:
731 // time(s), position
732 // -0.002, -2
733 // -0.001, -1
734 // -0.000, 0
735 size_t count = sizeof(values) / sizeof(Position);
736 computeAndCheckQuadraticEstimate(values, count, std::array<float, 3>({0, 1E3, 0}));
737}
738
739/*
740 * Parabola
741 */
742TEST_F(VelocityTrackerTest, LeastSquaresVelocityTrackerStrategyEstimator_Parabolic) {
743 Position values[] = {
744 { 0000000, 1, 1 },
745 { 1000000, 4, 4 },
746 { 2000000, 8, 8 },
747 };
748 // The data used for the fit will be as follows:
749 // time(s), position
750 // -0.002, 1
751 // -0.001, 4
752 // -0.000, 8
753 size_t count = sizeof(values) / sizeof(Position);
754 computeAndCheckQuadraticEstimate(values, count, std::array<float, 3>({8, 4.5E3, 0.5E6}));
755}
756
757/*
758 * Parabola
759 */
760TEST_F(VelocityTrackerTest, LeastSquaresVelocityTrackerStrategyEstimator_Parabolic2) {
761 Position values[] = {
762 { 0000000, 1, 1 },
763 { 1000000, 4, 4 },
764 { 2000000, 9, 9 },
765 };
766 // The data used for the fit will be as follows:
767 // time(s), position
768 // -0.002, 1
769 // -0.001, 4
770 // -0.000, 9
771 size_t count = sizeof(values) / sizeof(Position);
772 computeAndCheckQuadraticEstimate(values, count, std::array<float, 3>({9, 6E3, 1E6}));
773}
774
775/*
776 * Parabola :: y = x^2 :: the constant and linear coefficients are zero.
777 */
778TEST_F(VelocityTrackerTest, LeastSquaresVelocityTrackerStrategyEstimator_Parabolic3) {
779 Position values[] = {
780 { 0000000, 4, 4 },
781 { 1000000, 1, 1 },
782 { 2000000, 0, 0 },
783 };
784 // The data used for the fit will be as follows:
785 // time(s), position
786 // -0.002, 4
787 // -0.001, 1
788 // -0.000, 0
789 size_t count = sizeof(values) / sizeof(Position);
790 computeAndCheckQuadraticEstimate(values, count, std::array<float, 3>({0, 0E3, 1E6}));
791}
Siarhei Vishniakoud4b607e2017-06-13 12:21:59 +0100792
793} // namespace android