Event smoothing in CrOS gesture recognizer.

ui/aura/gestures/velocity_calculator.cc

Index: ui/aura/gestures/velocity_calculator.cc
diff --git a/ui/aura/gestures/velocity_calculator.cc b/ui/aura/gestures/velocity_calculator.cc
new file mode 100644
index 0000000000000000000000000000000000000000..2082e8ec86d56f65d4afcc61b4bda350d78cc67d
--- /dev/null
+++ b/ui/aura/gestures/velocity_calculator.cc
@@ -0,0 +1,105 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/aura/gestures/velocity_calculator.h"
+
+namespace aura {
+
+VelocityCalculator::VelocityCalculator(int buffer_size)
+    : buffer_(new Point[buffer_size]) ,
+      index_(0),
+      num_valid_entries_(0),
+      buffer_size_(buffer_size),
+      x_velocity_(0),
+      y_velocity_(0),
+      velocities_stale_(false) {
+}
+
+float VelocityCalculator::XVelocity() {
+  if (velocities_stale_)
+    UpdateVelocity();
+  return x_velocity_;
+}
+
+float VelocityCalculator::YVelocity() {
+  if (velocities_stale_)
+    UpdateVelocity();
+  return y_velocity_;
+}
+
+void VelocityCalculator::PointSeen(int x, int y, int64 time) {
+  buffer_[index_].x = x;
+  buffer_[index_].y = y;
+  buffer_[index_].time = time;
+
+  index_ = (index_ + 1) % buffer_size_;
+  if (num_valid_entries_ < buffer_size_)
+    ++num_valid_entries_;
+
+  velocities_stale_ = true;
+}
+
+float VelocityCalculator::VelocitySquared() {
+  if (velocities_stale_)
+    UpdateVelocity();
+  return x_velocity_ * x_velocity_ + y_velocity_ * y_velocity_;
+}
+
+void VelocityCalculator::UpdateVelocity() {
+  // We don't have enough data to make a good estimate of the velocity.
+  if (num_valid_entries_ < buffer_size_)
+    return;
+
+  // Where A_i = A[i] - mean(A)
+  // x velocity = sum_i(x_i * t_i) / sum_i(t_i * t_i)
+  // This is an Ordinary Least Squares Regression
+
+  float mean_x = 0;
+  float mean_y = 0;
+  int64 mean_time = 0;
+
+  for (size_t i = 0; i < buffer_size_; ++i) {
+    mean_x += buffer_[i].x;
+    mean_y += buffer_[i].y;
+    mean_time += buffer_[i].time;
+  }
+
+  // Minimize number of divides
+  const float buffer_size_i = 1.0f / buffer_size_;
+
+  mean_x *= buffer_size_i;
+  mean_y *= buffer_size_i;
+
+  // The loss in accuracy due to rounding is insignificant compared to
+  // the error due to the resolution of the timer
+  mean_time *= buffer_size_i;

[Ian Vollick, 2012/02/02 23:31:10]

Will this not create a floating point value that gets converted back to an
int64, losing your precision?

+
+  float xt = 0;  // sum_i(x_i * t_i)
+  float yt = 0;  // sum_i(y_i * t_i)
+  int64 tt = 0;  // sum_i(t_i * t_i)
+
+  int64 t_i;
+
+  for (size_t i = 0; i < buffer_size_; ++i) {
+    t_i = (buffer_[i].time - mean_time);
+    xt += (buffer_[i].x - mean_x) * t_i;
+    yt += (buffer_[i].y - mean_y) * t_i;
+    tt += t_i * t_i;
+  }
+
+  // Convert time from microseconds to seconds
+  x_velocity_ = xt / (tt / 1000000.0f);
+  y_velocity_ = yt / (tt / 1000000.0f);
+  velocities_stale_ = false;
+}
+
+void VelocityCalculator::ClearHistory() {
+  index_ = 0;
+  num_valid_entries_ = 0;
+  x_velocity_ = 0;
+  y_velocity_ = 0;
+  velocities_stale_ = false;
+}
+
+}  // namespace aura