Merge pull request #35 from phaazon/fix/bézier

Fix Bézier interpolation.

CHANGELOG.md

@@ -1,3 +1,16 @@
+# 3.0.0
+
+> Sun Oct 20th 2019
+
+## Major changes
+
+- Sampling now requires the value of the key to be `Linear<T>` for `Interpolate<T>`. That is needed
+  to ease some interpolation mode (especially Bézier).
+
+## Patch changes
+
+- Fix Bézier interpolation when the next key is Bézier too.
+
 # 2.2.0
 
 > Mon Oct 17th 2019

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "splines"
-version = "2.2.0"
+version = "3.0.0"
 license = "BSD-3-Clause"
 authors = ["Dimitri Sabadie <dimitri.sabadie@gmail.com>"]
 description = "Spline interpolation made easy"
@@ -34,5 +34,16 @@ num-traits = { version = "0.2", optional = true }
 serde =  { version = "1", optional = true }
 serde_derive = { version = "1", optional = true }
 
+[dev-dependencies]
+float-cmp = "0.5"
+serde_json = "1"
+
 [package.metadata.docs.rs]
 all-features = true
+
+[[example]]
+name = "hello-world"
+
+[[example]]
+name = "serialization"
+required-features = ["serialization"]

examples/01-hello-world/Cargo.toml

@@ -1,7 +0,0 @@
-[package]
-name = "hello-world"
-version = "0.2.0"
-authors = ["Dimitri Sabadie <dimitri.sabadie@gmail.com>"]
-
-[dependencies]
-splines = "1.0.0-rc.2"

examples/02-serialization/Cargo.toml

@@ -1,8 +0,0 @@
-[package]
-name = "serialization"
-version = "0.2.0"
-authors = ["Dimitri Sabadie <dimitri.sabadie@gmail.com>"]
-
-[dependencies]
-serde_json = "1"
-splines =  { version = "1.0.0-rc.2", features = ["serialization"] }

examples/Cargo.toml

@@ -1,9 +0,0 @@
-[workspace]
-
-members = [
-  "01-hello-world",
-  "02-serialization"
-]
-
-[patch.crates-io]
-splines = { path = ".." }

src/interpolate.rs

@@ -45,7 +45,7 @@
 /// instance to know which trait your type must implement to be usable.
 ///
 /// [`Spline::sample`]: crate::spline::Spline::sample
-pub trait Interpolate<T>: Sized + Copy {
+pub trait Interpolate<T>: Sized + Copy + Linear<T> {
   /// Linear interpolation.
   fn lerp(a: Self, b: Self, t: T) -> Self;
 
@@ -240,10 +240,7 @@ where V: Linear<T>,
   let one_t_3 = one_t_2 * one_t;
   let three = T::one() + T::one() + T::one();
 
-  // mirror the “output” tangent based on the next key “input” tangent
+  a.outer_mul(one_t_3) + u.outer_mul(three * one_t_2 * t) + v.outer_mul(three * one_t * t * t) + b.outer_mul(t * t * t)
-  let v_ = b + b - v;
-
-  a.outer_mul(one_t_3) + u.outer_mul(three * one_t_2 * t) + v_.outer_mul(three * one_t * t * t) + b.outer_mul(t * t * t)
 }
 
 macro_rules! impl_interpolate_simple {

src/spline.rs

@@ -7,7 +7,7 @@
 #[cfg(not(feature = "std"))] use core::ops::{Div, Mul};
 #[cfg(not(feature = "std"))] use core::cmp::Ordering;
 
-use crate::interpolate::{Interpolate, Additive, One, Trigo};
+use crate::interpolate::{Additive, Interpolate, One, Trigo};
 use crate::interpolation::Interpolation;
 use crate::key::Key;
 
@@ -86,7 +86,7 @@ impl<T, V> Spline<T, V> {
   /// the sampling.
   pub fn sample_with_key(&self, t: T) -> Option<(V, &Key<T, V>, Option<&Key<T, V>>)>
   where T: Additive + One + Trigo + Mul<T, Output = T> + Div<T, Output = T> + PartialOrd,
-        V: Interpolate<T> {
+        V: Additive + Interpolate<T> {
     let keys = &self.0;
     let i = search_lower_cp(keys, t)?;
     let cp0 = &keys[i];
@@ -134,29 +134,27 @@ impl<T, V> Spline<T, V> {
         }
       }
 
-      Interpolation::Bezier(u) => {
+      Interpolation::Bezier(u) | Interpolation::StrokeBezier(_, u) => {
         // We need to check the next control point to see whether we want quadratic or cubic Bezier.
         let cp1 = &keys[i + 1];
         let nt = normalize_time(t, cp0, cp1);
 
         let value =
-          if let Interpolation::Bezier(v) = cp1.interpolation {
+          match cp1.interpolation {
-            Interpolate::cubic_bezier(cp0.value, u, v, cp1.value, nt)
+            Interpolation::Bezier(v) => {
-          } else {
+              Interpolate::cubic_bezier(cp0.value, u, cp1.value + cp1.value - v, cp1.value, nt)
-            Interpolate::quadratic_bezier(cp0.value, u, cp1.value, nt)
+            }
+
+            Interpolation::StrokeBezier(v, _) => {
+              Interpolate::cubic_bezier(cp0.value, u, v, cp1.value, nt)
+            }
+
+            _ => Interpolate::quadratic_bezier(cp0.value, u, cp1.value, nt)
           };
 
         Some((value, cp0, Some(cp1)))
       }
 
-      Interpolation::StrokeBezier(input, output) => {
-        let cp1 = &keys[i + 1];
-        let nt = normalize_time(t, cp0, cp1);
-        let value = Interpolate::cubic_bezier(cp0.value, input, output, cp1.value, nt);
-
-        Some((value, cp0, Some(cp1)))
-      }
-
       Interpolation::__NonExhaustive => unreachable!(),
     }
   }
@@ -165,7 +163,7 @@ impl<T, V> Spline<T, V> {
   ///
   pub fn sample(&self, t: T) -> Option<V>
   where T: Additive + One + Trigo + Mul<T, Output = T> + Div<T, Output = T> + PartialOrd,
-        V: Interpolate<T> {
+        V: Additive + Interpolate<T> {
     self.sample_with_key(t).map(|(v, _, _)| v)
   }
 
@@ -182,7 +180,7 @@ impl<T, V> Spline<T, V> {
   /// This function returns [`None`] if you have no key.
   pub fn clamped_sample_with_key(&self, t: T) -> Option<(V, &Key<T, V>, Option<&Key<T, V>>)>
   where T: Additive + One + Trigo + Mul<T, Output = T> + Div<T, Output = T> + PartialOrd,
-        V: Interpolate<T> {
+        V: Additive + Interpolate<T> {
     if self.0.is_empty() {
       return None;
     }
@@ -207,7 +205,7 @@ impl<T, V> Spline<T, V> {
   /// Sample a spline at a given time with clamping.
   pub fn clamped_sample(&self, t: T) -> Option<V>
   where T: Additive + One + Trigo + Mul<T, Output = T> + Div<T, Output = T> + PartialOrd,
-        V: Interpolate<T> {
+        V: Additive + Interpolate<T> {
     self.clamped_sample_with_key(t).map(|(v, _, _)| v)
   }
 

tests/mod.rs

@@ -1,7 +1,8 @@
+use float_cmp::approx_eq;
 use splines::{Interpolation, Key, Spline};
 
-#[cfg(feature = "impl-cgmath")] use cgmath as cg;
+#[cfg(feature = "cgmath")] use cgmath as cg;
-#[cfg(feature = "impl-nalgebra")] use nalgebra as na;
+#[cfg(feature = "nalgebra")] use nalgebra as na;
 
 #[test]
 fn step_interpolation_f32() {
@@ -149,7 +150,24 @@ fn several_interpolations_several_keys() {
   assert_eq!(spline.clamped_sample(11.), Some(4.));
 }
 
-#[cfg(feature = "impl-cgmath")]
+#[cfg(feature = "cgmath")]
+#[test]
+fn stroke_bezier_straight() {
+  let keys = vec![
+    Key::new(0.0, cg::Vector2::new(0., 1.), Interpolation::StrokeBezier(cg::Vector2::new(0., 1.), cg::Vector2::new(0., 1.))),
+    Key::new(5.0, cg::Vector2::new(5., 1.), Interpolation::StrokeBezier(cg::Vector2::new(5., 1.), cg::Vector2::new(5., 1.)))
+  ];
+  let spline = Spline::from_vec(keys);
+
+  assert!(approx_eq!(f32, spline.clamped_sample(0.0).unwrap().y, 1.));
+  assert!(approx_eq!(f32, spline.clamped_sample(1.0).unwrap().y, 1.));
+  assert!(approx_eq!(f32, spline.clamped_sample(2.0).unwrap().y, 1.));
+  assert!(approx_eq!(f32, spline.clamped_sample(3.0).unwrap().y, 1.));
+  assert!(approx_eq!(f32, spline.clamped_sample(4.0).unwrap().y, 1.));
+  assert!(approx_eq!(f32, spline.clamped_sample(5.0).unwrap().y, 1.));
+}
+
+#[cfg(feature = "cgmath")]
 #[test]
 fn cgmath_vector_interpolation() {
   use splines::Interpolate;
@@ -163,7 +181,7 @@ fn cgmath_vector_interpolation() {
   assert_eq!(Interpolate::lerp(start, end, 0.5), mid);
 }
 
-#[cfg(feature = "impl-nalgebra")]
+#[cfg(feature = "nalgebra")]
 #[test]
 fn nalgebra_vector_interpolation() {
   use splines::Interpolate;