flickable: calcualte touch velocity

Author: igagis

src/ruis/widget/base/touch/flickable.cpp

@@ -22,6 +22,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
 #include "flickable.hpp"
 
 #include <utki/time.hpp>
+#include <utki/views.hpp>
 
 using namespace ruis::touch;
 
@@ -185,17 +186,26 @@ void flickable::update(uint32_t dt_ms)
 	// TODO:
 }
 
+namespace{
+constexpr auto max_history_records = 10;
+}
+
 void flickable::push_touch_move_to_history(touch_move_info tm){
-	constexpr auto max_history_records = 10;
 	constexpr auto max_history_age_ms = 200;
 	constexpr auto min_time_between_points_ms = 1;
 
+	// drop too old records
+	while(!this->touch_history.empty() && tm.timestamp_ms - this->touch_history.front().timestamp_ms > max_history_age_ms){
+		this->touch_history.pop_front();
+	}
+
 	if(this->touch_history.empty()){
 		this->touch_history.push_back(std::move(tm));
 		return;
 	}
 
 	utki::assert(!this->touch_history.empty(), SL);
+
 	auto& last_record = this->touch_history.back();
 
 	if(tm.timestamp_ms - last_record.timestamp_ms <= min_time_between_points_ms){
@@ -213,7 +223,7 @@ void flickable::push_touch_move_to_history(touch_move_info tm){
 
 ruis::vec2 flickable::calculate_touch_velocity(){
 	if(this->touch_history.size() < 2){
-		std::cout << "flickable::calculate_touch_velocity(): return 0. this->touch_history.size() = " << this->touch_history.size() << std::endl;
+		// std::cout << "flickable::calculate_touch_velocity(): return 0. this->touch_history.size() = " << this->touch_history.size() << std::endl;
 		return {0};
 	}
 
@@ -228,13 +238,94 @@ ruis::vec2 flickable::calculate_touch_velocity(){
 
 		auto vel = dp / ruis::real(dt_ms);
 
-		std::cout << "flickable::calculate_touch_velocity(): return " << vel << ". this->touch_history.size() = " << this->touch_history.size() << std::endl;
+		// std::cout << "flickable::calculate_touch_velocity(): return " << vel << ". this->touch_history.size() = " << this->touch_history.size() << std::endl;
 		return vel;
 	}
 
-	// TODO:
-	ruis::vec2 vel = 0;
+	// use Ordinary Least Squares method to fit a quadratic curve to the points of touch history
+	ruis::vec2 vel = calculate_touch_velocity_for_at_least_3_points_using_ols_method();
 
-	std::cout << "flickable::calculate_touch_velocity(): return " << vel << ". this->touch_history.size() = " << this->touch_history.size() << std::endl;
+	// std::cout << "flickable::calculate_touch_velocity(): return " << vel << ". this->touch_history.size() = " << this->touch_history.size() << std::endl;
 	return vel;
 }
+
+ruis::vec2 flickable::calculate_touch_velocity_for_at_least_3_points_using_ols_method(){
+	// Ordinary Least Squares method fits quadratic curve y(t)=a*t^2+b*t+c to a set of n >= 3 points.
+	// Coefficients a, b and c can be found by solving the following system of linear equations
+	//
+	// / sum(t^4) sum(t^3) sum(t^2) \   / a \   / sum(y * t^2) \
+	// | sum(t^3) sum(t^2) sum(t)   | * | b | = | sum(y * t)   |
+	// \ sum(t^2) sum(t)   n        /   \ c /   \ sum(y)       /
+	//
+	// The touch velocity is effectively v = dy/dt = 2*a*t + b
+	//
+	// If we bias t foe each point to the last point, i.e. last point will be at t=0 and previous
+	// points will be at some negative times, then v(0) = b.
+	// Effecively the touch velocity is the b coefficient.
+
+	// need at least 3 points for quadratic curve fitting
+	utki::assert(this->touch_history.size() >= 3, SL);
+
+	uint32_t time_bias_ms = this->touch_history.back().timestamp_ms;
+
+	ruis::real time_sum = 0;
+	ruis::real time_pow2_sum = 0;
+	ruis::real time_pow3_sum = 0;
+	ruis::real time_pow4_sum = 0;
+	ruis::vec2 pos_time_pow2_sum = 0;
+	ruis::vec2 pos_time_sum = 0;
+	ruis::vec2 pos_sum = 0;
+
+	for(const auto& rec : this->touch_history){
+		// Here we still do arithmetics in uint32_t space.
+		// The time_bias_ms is the latest timestamp, so subtract from it to get positive biased time.
+		uint32_t shifted_time = time_bias_ms - rec.timestamp_ms;
+
+		// since we bias to lates timestamp, the actual biased time should be negative
+		ruis::real t = -ruis::real(shifted_time);
+
+		ruis::real t_pow2 = t * t;
+		ruis::real t_pow3 = t_pow2 * t;
+		ruis::real t_pow4 = t_pow3 * t;
+
+		// std::cout << "shifted time = " << t << std::endl;
+
+		time_sum += t;
+		time_pow2_sum += t_pow2;
+		time_pow3_sum += t_pow3;
+		time_pow4_sum += t_pow4;
+
+		pos_sum += rec.position;
+		pos_time_sum += rec.position * t;
+		pos_time_pow2_sum += rec.position * t_pow2;
+	}
+
+	// clang-format off
+	ruis::mat3 m{
+		{time_pow4_sum, time_pow3_sum, time_pow2_sum},
+		{time_pow3_sum, time_pow2_sum, time_sum},
+		{time_pow2_sum, time_sum, this->touch_history.size()}
+	};
+	// clang-format on
+
+	auto det = m.det();
+
+	constexpr auto epsilon = ruis::real(1e-9);
+
+	using std::abs;
+	if(abs(det) < epsilon){
+		// the matrix is not invertible
+		return {0};
+	}
+
+	// replace 2nd column with right-hand side vector and calculate determinant
+	ruis::vec2 det_b;
+	for(auto [p0, p1, p2, out] : utki::views::zip(pos_time_pow2_sum, pos_time_sum, pos_sum, det_b)){
+		m[0][1] = p0;
+		m[1][1] = p1;
+		m[2][1] = p2;
+		out = m.det();
+	}
+
+	return det_b.comp_div(det);
+}

src/ruis/widget/base/touch/flickable.hpp

@@ -60,6 +60,8 @@ class flickable :
 	void push_touch_move_to_history(touch_move_info tm);
 	vec2 calculate_touch_velocity();
 
+	ruis::vec2 calculate_touch_velocity_for_at_least_3_points_using_ols_method();
+
 public:
 	event_status on_mouse_button(const mouse_button_event& event) override;
 	event_status on_mouse_move(const mouse_move_event& event) override;