Event smoothing in CrOS gesture recognizer.

ui/aura/gestures/velocity_calculator.cc

+// 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)
+    : index_(0)
+    , num_valid_entries_(0)
+    , buffer_size_(buffer_size)
+    , x_velocity_(0)
+    , y_velocity_(0) {
+  buffer_ = new Point[buffer_size];
+}
+
+VelocityCalculator::~VelocityCalculator() {
+  delete buffer_;
+}
+
+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_;
+
+  UpdateVelocity();

[sadrul, 2012/02/02 20:34:01]

I kind of liked the way you did it in the first patchset. PointSeen is called a
lot often and a lot more (potentially for every touch) than x_velocity() or
y_velocity() (only at the end of a scroll gesture). It fells like computing the
actual velocities on demand would be better, rather than spending cycles
computing velocities for every touch?

+}
+
+float VelocityCalculator::VelocitySquared() const {
+  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;
+  }
+
+  mean_x /= buffer_size_;

[rjkroege, 2012/02/02 20:24:17]

compute the reciprocal once and then multiply?

+  mean_y /= buffer_size_;
+
+  // The loss in accuracy due to rounding is insignificant compared to
+  // the error due to the resolution of the timer
+  mean_time /= buffer_size_;
+
+  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);
+}
+
+void VelocityCalculator::ClearHistory() {
+  index_ = 0;
+  num_valid_entries_ = 0;
+  x_velocity_ = 0;
+  y_velocity_ = 0;
+}
+
+}  // namespace aura