max/splines
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

run rustfmt

Browse Source
This commit is contained in:
Alexander Bulaev 2020-03-18 13:59:22 +03:00
parent efe9272816
commit 4630f44d6c
11 changed files with 808 additions and 710 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
examples/hello-world.rs
View File

@ -3,9 +3,12 @@ extern crate splines;
use splines::{Interpolation, Key, Spline}; use splines::{Interpolation, Key, Spline};
fn main() { fn main() {
let keys = vec![Key::new(0., 0., Interpolation::default()), Key::new(5., 1., Interpolation::default())]; let keys = vec![
let spline = Spline::from_vec(keys); Key::new(0., 0., Interpolation::default()),
Key::new(5., 1., Interpolation::default()),
];
let spline = Spline::from_vec(keys);
println!("value at 0: {:?}", spline.clamped_sample(0.)); println!("value at 0: {:?}", spline.clamped_sample(0.));
println!("value at 3: {:?}", spline.clamped_sample(3.)); println!("value at 3: {:?}", spline.clamped_sample(3.));
} }

45
examples/serialization.rs
View File

@ -1,30 +1,31 @@
#[macro_use] extern crate serde_json; #[macro_use]
extern crate serde_json;
extern crate splines; extern crate splines;
use serde_json::from_value; use serde_json::from_value;
use splines::Spline; use splines::Spline;
fn main() { fn main() {
let value = json!{ let value = json! {
[ [
{ {
"t": 0, "t": 0,
"interpolation": "linear", "interpolation": "linear",
"value": 0 "value": 0
}, },
{ {
"t": 1, "t": 1,
"interpolation": { "step": 0.5 }, "interpolation": { "step": 0.5 },
"value": 1 "value": 1
}, },
{ {
"t": 5, "t": 5,
"interpolation": "cosine", "interpolation": "cosine",
"value": 10 "value": 10
}, },
] ]
}; };
let spline = from_value::<Spline<f32, f32>>(value); let spline = from_value::<Spline<f32, f32>>(value);
println!("{:?}", spline); println!("{:?}", spline);
} }

62
src/cgmath.rs
View File

@ -1,9 +1,9 @@
use cgmath::{ use cgmath::{
BaseFloat, BaseNum, InnerSpace, Quaternion, Vector1, Vector2, Vector3, Vector4, VectorSpace BaseFloat, BaseNum, InnerSpace, Quaternion, Vector1, Vector2, Vector3, Vector4, VectorSpace,
}; };
use crate::interpolate::{ use crate::interpolate::{
Additive, Interpolate, Linear, One, cubic_bezier_def, cubic_hermite_def, quadratic_bezier_def cubic_bezier_def, cubic_hermite_def, quadratic_bezier_def, Additive, Interpolate, Linear, One,
}; };
macro_rules! impl_interpolate_vec { macro_rules! impl_interpolate_vec {
@ -50,37 +50,43 @@ impl_interpolate_vec!(Vector2);
impl_interpolate_vec!(Vector3); impl_interpolate_vec!(Vector3);
impl_interpolate_vec!(Vector4); impl_interpolate_vec!(Vector4);
impl<T> Linear<T> for Quaternion<T> where T: BaseFloat { impl<T> Linear<T> for Quaternion<T>
#[inline(always)] where
fn outer_mul(self, t: T) -> Self { T: BaseFloat,
self * t {
} #[inline(always)]
fn outer_mul(self, t: T) -> Self {
self * t
}
#[inline(always)] #[inline(always)]
fn outer_div(self, t: T) -> Self { fn outer_div(self, t: T) -> Self {
self / t self / t
} }
} }
impl<T> Interpolate<T> for Quaternion<T> impl<T> Interpolate<T> for Quaternion<T>
where Self: InnerSpace<Scalar = T>, T: Additive + BaseFloat + One { where
#[inline(always)] Self: InnerSpace<Scalar = T>,
fn lerp(a: Self, b: Self, t: T) -> Self { T: Additive + BaseFloat + One,
a.nlerp(b, t) {
} #[inline(always)]
fn lerp(a: Self, b: Self, t: T) -> Self {
a.nlerp(b, t)
}
#[inline(always)] #[inline(always)]
fn cubic_hermite(x: (Self, T), a: (Self, T), b: (Self, T), y: (Self, T), t: T) -> Self { fn cubic_hermite(x: (Self, T), a: (Self, T), b: (Self, T), y: (Self, T), t: T) -> Self {
cubic_hermite_def(x, a, b, y, t) cubic_hermite_def(x, a, b, y, t)
} }
#[inline(always)] #[inline(always)]
fn quadratic_bezier(a: Self, u: Self, b: Self, t: T) -> Self { fn quadratic_bezier(a: Self, u: Self, b: Self, t: T) -> Self {
quadratic_bezier_def(a, u, b, t) quadratic_bezier_def(a, u, b, t)
} }
#[inline(always)] #[inline(always)]
fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: T) -> Self { fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: T) -> Self {
cubic_bezier_def(a, u, v, b, t) cubic_bezier_def(a, u, v, b, t)
} }
} }

348
src/interpolate.rs
View File

@ -28,14 +28,22 @@
//! [`Trigo`]: crate::interpolate::Trigo //! [`Trigo`]: crate::interpolate::Trigo
//! [num-traits]: https://crates.io/crates/num-traits //! [num-traits]: https://crates.io/crates/num-traits
#[cfg(feature = "std")] use std::f32; #[cfg(not(feature = "std"))]
#[cfg(not(feature = "std"))] use core::f32; use core::f32;
#[cfg(not(feature = "std"))] use core::intrinsics::cosf32; #[cfg(not(feature = "std"))]
#[cfg(feature = "std")] use std::f64; use core::f64;
#[cfg(not(feature = "std"))] use core::f64; #[cfg(not(feature = "std"))]
#[cfg(not(feature = "std"))] use core::intrinsics::cosf64; use core::intrinsics::cosf32;
#[cfg(feature = "std")] use std::ops::{Add, Mul, Sub}; #[cfg(not(feature = "std"))]
#[cfg(not(feature = "std"))] use core::ops::{Add, Mul, Sub}; use core::intrinsics::cosf64;
#[cfg(not(feature = "std"))]
use core::ops::{Add, Mul, Sub};
#[cfg(feature = "std")]
use std::f32;
#[cfg(feature = "std")]
use std::f64;
#[cfg(feature = "std")]
use std::ops::{Add, Mul, Sub};
/// Keys that can be interpolated in between. Implementing this trait is required to perform /// Keys that can be interpolated in between. Implementing this trait is required to perform
/// sampling on splines. /// sampling on splines.
@ -46,80 +54,72 @@
/// ///
/// [`Spline::sample`]: crate::spline::Spline::sample /// [`Spline::sample`]: crate::spline::Spline::sample
pub trait Interpolate<T>: Sized + Copy + Linear<T> { pub trait Interpolate<T>: Sized + Copy + Linear<T> {
/// Linear interpolation. /// Linear interpolation.
fn lerp(a: Self, b: Self, t: T) -> Self; fn lerp(a: Self, b: Self, t: T) -> Self;
/// Cubic hermite interpolation. /// Cubic hermite interpolation.
/// ///
/// Default to [`lerp`]. /// Default to [`lerp`].
/// ///
/// [`lerp`]: Interpolate::lerp /// [`lerp`]: Interpolate::lerp
fn cubic_hermite(_: (Self, T), a: (Self, T), b: (Self, T), _: (Self, T), t: T) -> Self { fn cubic_hermite(_: (Self, T), a: (Self, T), b: (Self, T), _: (Self, T), t: T) -> Self {
Self::lerp(a.0, b.0, t) Self::lerp(a.0, b.0, t)
} }
/// Quadratic Bézier interpolation. /// Quadratic Bézier interpolation.
fn quadratic_bezier(a: Self, u: Self, b: Self, t: T) -> Self; fn quadratic_bezier(a: Self, u: Self, b: Self, t: T) -> Self;
/// Cubic Bézier interpolation. /// Cubic Bézier interpolation.
fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: T) -> Self; fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: T) -> Self;
} }
/// Set of types that support additions and subtraction. /// Set of types that support additions and subtraction.
/// ///
/// The [`Copy`] trait is also a supertrait as it’s likely to be used everywhere. /// The [`Copy`] trait is also a supertrait as it’s likely to be used everywhere.
pub trait Additive: pub trait Additive: Copy + Add<Self, Output = Self> + Sub<Self, Output = Self> {}
Copy +
Add<Self, Output = Self> +
Sub<Self, Output = Self> {
}
impl<T> Additive for T impl<T> Additive for T where T: Copy + Add<Self, Output = Self> + Sub<Self, Output = Self> {}
where T: Copy +
Add<Self, Output = Self> +
Sub<Self, Output = Self> {
}
/// Set of additive types that support outer multiplication and division, making them linear. /// Set of additive types that support outer multiplication and division, making them linear.
pub trait Linear<T>: Additive { pub trait Linear<T>: Additive {
/// Apply an outer multiplication law. /// Apply an outer multiplication law.
fn outer_mul(self, t: T) -> Self; fn outer_mul(self, t: T) -> Self;
/// Apply an outer division law. /// Apply an outer division law.
fn outer_div(self, t: T) -> Self; fn outer_div(self, t: T) -> Self;
} }
macro_rules! impl_linear_simple { macro_rules! impl_linear_simple {
($t:ty) => { ($t:ty) => {
impl Linear<$t> for $t { impl Linear<$t> for $t {
fn outer_mul(self, t: $t) -> Self { fn outer_mul(self, t: $t) -> Self {
self * t self * t
} }
/// Apply an outer division law. /// Apply an outer division law.
fn outer_div(self, t: $t) -> Self { fn outer_div(self, t: $t) -> Self {
self / t self / t
} }
} }
} };
} }
impl_linear_simple!(f32); impl_linear_simple!(f32);
impl_linear_simple!(f64); impl_linear_simple!(f64);
macro_rules! impl_linear_cast { macro_rules! impl_linear_cast {
($t:ty, $q:ty) => { ($t:ty, $q:ty) => {
impl Linear<$t> for $q { impl Linear<$t> for $q {
fn outer_mul(self, t: $t) -> Self { fn outer_mul(self, t: $t) -> Self {
self * t as $q self * t as $q
} }
/// Apply an outer division law. /// Apply an outer division law.
fn outer_div(self, t: $t) -> Self { fn outer_div(self, t: $t) -> Self {
self / t as $q self / t as $q
} }
} }
} };
} }
impl_linear_cast!(f32, f64); impl_linear_cast!(f32, f64);
@ -127,19 +127,19 @@ impl_linear_cast!(f64, f32);
/// Types with a neutral element for multiplication. /// Types with a neutral element for multiplication.
pub trait One { pub trait One {
/// The neutral element for the multiplicative monoid — typically called `1`. /// The neutral element for the multiplicative monoid — typically called `1`.
fn one() -> Self; fn one() -> Self;
} }
macro_rules! impl_one_float { macro_rules! impl_one_float {
($t:ty) => { ($t:ty) => {
impl One for $t { impl One for $t {
#[inline(always)] #[inline(always)]
fn one() -> Self { fn one() -> Self {
1. 1.
} }
} }
} };
} }
impl_one_float!(f32); impl_one_float!(f32);
@ -147,147 +147,177 @@ impl_one_float!(f64);
/// Types with a sane definition of π and cosine. /// Types with a sane definition of π and cosine.
pub trait Trigo { pub trait Trigo {
/// π. /// π.
fn pi() -> Self; fn pi() -> Self;
/// Cosine of the argument. /// Cosine of the argument.
fn cos(self) -> Self; fn cos(self) -> Self;
} }
impl Trigo for f32 { impl Trigo for f32 {
#[inline(always)] #[inline(always)]
fn pi() -> Self { fn pi() -> Self {
f32::consts::PI f32::consts::PI
}
#[inline(always)]
fn cos(self) -> Self {
#[cfg(feature = "std")]
{
self.cos()
} }
#[cfg(not(feature = "std"))] #[inline(always)]
{ fn cos(self) -> Self {
unsafe { cosf32(self) } #[cfg(feature = "std")]
{
self.cos()
}
#[cfg(not(feature = "std"))]
{
unsafe { cosf32(self) }
}
} }
}
} }
impl Trigo for f64 { impl Trigo for f64 {
#[inline(always)] #[inline(always)]
fn pi() -> Self { fn pi() -> Self {
f64::consts::PI f64::consts::PI
}
#[inline(always)]
fn cos(self) -> Self {
#[cfg(feature = "std")]
{
self.cos()
} }
#[cfg(not(feature = "std"))] #[inline(always)]
{ fn cos(self) -> Self {
unsafe { cosf64(self) } #[cfg(feature = "std")]
{
self.cos()
}
#[cfg(not(feature = "std"))]
{
unsafe { cosf64(self) }
}
} }
}
} }
/// Default implementation of [`Interpolate::cubic_hermite`]. /// Default implementation of [`Interpolate::cubic_hermite`].
/// ///
/// `V` is the value being interpolated. `T` is the sampling value (also sometimes called time). /// `V` is the value being interpolated. `T` is the sampling value (also sometimes called time).
pub fn cubic_hermite_def<V, T>(x: (V, T), a: (V, T), b: (V, T), y: (V, T), t: T) -> V pub fn cubic_hermite_def<V, T>(x: (V, T), a: (V, T), b: (V, T), y: (V, T), t: T) -> V
where V: Linear<T>, where
T: Additive + Mul<T, Output = T> + One { V: Linear<T>,
// some stupid generic constants, because Rust doesn’t have polymorphic literals… T: Additive + Mul<T, Output = T> + One,
let one_t = T::one(); {
let two_t = one_t + one_t; // lolololol // some stupid generic constants, because Rust doesn’t have polymorphic literals…
let three_t = two_t + one_t; // megalol let one_t = T::one();
let two_t = one_t + one_t; // lolololol
let three_t = two_t + one_t; // megalol
// sampler stuff // sampler stuff
let t2 = t * t; let t2 = t * t;
let t3 = t2 * t; let t3 = t2 * t;
let two_t3 = t3 * two_t; let two_t3 = t3 * two_t;
let three_t2 = t2 * three_t; let three_t2 = t2 * three_t;
// tangents // tangents
let m0 = (b.0 - x.0).outer_div(b.1 - x.1); let m0 = (b.0 - x.0).outer_div(b.1 - x.1);
let m1 = (y.0 - a.0).outer_div(y.1 - a.1); let m1 = (y.0 - a.0).outer_div(y.1 - a.1);
a.0.outer_mul(two_t3 - three_t2 + one_t) + m0.outer_mul(t3 - t2 * two_t + t) + b.0.outer_mul(three_t2 - two_t3) + m1.outer_mul(t3 - t2) a.0.outer_mul(two_t3 - three_t2 + one_t)
+ m0.outer_mul(t3 - t2 * two_t + t)
+ b.0.outer_mul(three_t2 - two_t3)
+ m1.outer_mul(t3 - t2)
} }
/// Default implementation of [`Interpolate::quadratic_bezier`]. /// Default implementation of [`Interpolate::quadratic_bezier`].
/// ///
/// `V` is the value being interpolated. `T` is the sampling value (also sometimes called time). /// `V` is the value being interpolated. `T` is the sampling value (also sometimes called time).
pub fn quadratic_bezier_def<V, T>(a: V, u: V, b: V, t: T) -> V pub fn quadratic_bezier_def<V, T>(a: V, u: V, b: V, t: T) -> V
where V: Linear<T>, where
T: Additive + Mul<T, Output = T> + One { V: Linear<T>,
let one_t = T::one() - t; T: Additive + Mul<T, Output = T> + One,
let one_t_2 = one_t * one_t; {
u + (a - u).outer_mul(one_t_2) + (b - u).outer_mul(t * t) let one_t = T::one() - t;
let one_t_2 = one_t * one_t;
u + (a - u).outer_mul(one_t_2) + (b - u).outer_mul(t * t)
} }
/// Default implementation of [`Interpolate::cubic_bezier`]. /// Default implementation of [`Interpolate::cubic_bezier`].
/// ///
/// `V` is the value being interpolated. `T` is the sampling value (also sometimes called time). /// `V` is the value being interpolated. `T` is the sampling value (also sometimes called time).
pub fn cubic_bezier_def<V, T>(a: V, u: V, v: V, b: V, t: T) -> V pub fn cubic_bezier_def<V, T>(a: V, u: V, v: V, b: V, t: T) -> V
where V: Linear<T>, where
T: Additive + Mul<T, Output = T> + One { V: Linear<T>,
let one_t = T::one() - t; T: Additive + Mul<T, Output = T> + One,
let one_t_2 = one_t * one_t; {
let one_t_3 = one_t_2 * one_t; let one_t = T::one() - t;
let three = T::one() + T::one() + T::one(); let one_t_2 = one_t * one_t;
let one_t_3 = one_t_2 * one_t;
let three = T::one() + T::one() + T::one();
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) 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 { macro_rules! impl_interpolate_simple {
($t:ty) => { ($t:ty) => {
impl Interpolate<$t> for $t { impl Interpolate<$t> for $t {
fn lerp(a: Self, b: Self, t: $t) -> Self { fn lerp(a: Self, b: Self, t: $t) -> Self {
a * (1. - t) + b * t a * (1. - t) + b * t
} }
fn cubic_hermite(x: (Self, $t), a: (Self, $t), b: (Self, $t), y: (Self, $t), t: $t) -> Self { fn cubic_hermite(
cubic_hermite_def(x, a, b, y, t) x: (Self, $t),
} a: (Self, $t),
b: (Self, $t),
y: (Self, $t),
t: $t,
) -> Self {
cubic_hermite_def(x, a, b, y, t)
}
fn quadratic_bezier(a: Self, u: Self, b: Self, t: $t) -> Self { fn quadratic_bezier(a: Self, u: Self, b: Self, t: $t) -> Self {
quadratic_bezier_def(a, u, b, t) quadratic_bezier_def(a, u, b, t)
} }
fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: $t) -> Self { fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: $t) -> Self {
cubic_bezier_def(a, u, v, b, t) cubic_bezier_def(a, u, v, b, t)
} }
} }
} };
} }
impl_interpolate_simple!(f32); impl_interpolate_simple!(f32);
impl_interpolate_simple!(f64); impl_interpolate_simple!(f64);
macro_rules! impl_interpolate_via { macro_rules! impl_interpolate_via {
($t:ty, $v:ty) => { ($t:ty, $v:ty) => {
impl Interpolate<$t> for $v { impl Interpolate<$t> for $v {
fn lerp(a: Self, b: Self, t: $t) -> Self { fn lerp(a: Self, b: Self, t: $t) -> Self {
a * (1. - t as $v) + b * t as $v a * (1. - t as $v) + b * t as $v
} }
fn cubic_hermite((x, xt): (Self, $t), (a, at): (Self, $t), (b, bt): (Self, $t), (y, yt): (Self, $t), t: $t) -> Self { fn cubic_hermite(
cubic_hermite_def((x, xt as $v), (a, at as $v), (b, bt as $v), (y, yt as $v), t as $v) (x, xt): (Self, $t),
} (a, at): (Self, $t),
(b, bt): (Self, $t),
(y, yt): (Self, $t),
t: $t,
) -> Self {
cubic_hermite_def(
(x, xt as $v),
(a, at as $v),
(b, bt as $v),
(y, yt as $v),
t as $v,
)
}
fn quadratic_bezier(a: Self, u: Self, b: Self, t: $t) -> Self { fn quadratic_bezier(a: Self, u: Self, b: Self, t: $t) -> Self {
quadratic_bezier_def(a, u, b, t as $v) quadratic_bezier_def(a, u, b, t as $v)
} }
fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: $t) -> Self { fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: $t) -> Self {
cubic_bezier_def(a, u, v, b, t as $v) cubic_bezier_def(a, u, v, b, t as $v)
} }
} }
} };
} }
impl_interpolate_via!(f32, f64); impl_interpolate_via!(f32, f64);

101
src/interpolation.rs
View File

@ -1,6 +1,7 @@
//! Available interpolation modes. //! Available interpolation modes.
#[cfg(feature = "serialization")] use serde_derive::{Deserialize, Serialize}; #[cfg(feature = "serialization")]
use serde_derive::{Deserialize, Serialize};
/// Available kind of interpolations. /// Available kind of interpolations.
/// ///
@ -9,56 +10,56 @@
#[cfg_attr(feature = "serialization", derive(Deserialize, Serialize))] #[cfg_attr(feature = "serialization", derive(Deserialize, Serialize))]
#[cfg_attr(feature = "serialization", serde(rename_all = "snake_case"))] #[cfg_attr(feature = "serialization", serde(rename_all = "snake_case"))]
pub enum Interpolation<T, V> { pub enum Interpolation<T, V> {
/// Hold a [`Key`] until the sampling value passes the normalized step threshold, in which /// Hold a [`Key`] until the sampling value passes the normalized step threshold, in which
/// case the next key is used. /// case the next key is used.
/// ///
/// > Note: if you set the threshold to `0.5`, the first key will be used until half the time /// > Note: if you set the threshold to `0.5`, the first key will be used until half the time
/// > between the two keys; the second key will be in used afterwards. If you set it to `1.0`, the /// > between the two keys; the second key will be in used afterwards. If you set it to `1.0`, the
/// > first key will be kept until the next key. Set it to `0.` and the first key will never be /// > first key will be kept until the next key. Set it to `0.` and the first key will never be
/// > used. /// > used.
/// ///
/// [`Key`]: crate::key::Key /// [`Key`]: crate::key::Key
Step(T), Step(T),
/// Linear interpolation between a key and the next one. /// Linear interpolation between a key and the next one.
Linear, Linear,
/// Cosine interpolation between a key and the next one. /// Cosine interpolation between a key and the next one.
Cosine, Cosine,
/// Catmull-Rom interpolation, performing a cubic Hermite interpolation using four keys. /// Catmull-Rom interpolation, performing a cubic Hermite interpolation using four keys.
CatmullRom, CatmullRom,
/// Bézier interpolation. /// Bézier interpolation.
/// ///
/// A control point that uses such an interpolation is associated with an extra point. The segmant /// A control point that uses such an interpolation is associated with an extra point. The segmant
/// connecting both is called the _tangent_ of this point. The part of the spline defined between /// connecting both is called the _tangent_ of this point. The part of the spline defined between
/// this control point and the next one will be interpolated across with Bézier interpolation. Two /// this control point and the next one will be interpolated across with Bézier interpolation. Two
/// cases are possible: /// cases are possible:
/// ///
/// - The next control point also has a Bézier interpolation mode. In this case, its tangent is /// - The next control point also has a Bézier interpolation mode. In this case, its tangent is
/// used for the interpolation process. This is called _cubic Bézier interpolation_ and it /// used for the interpolation process. This is called _cubic Bézier interpolation_ and it
/// kicks ass. /// kicks ass.
/// - The next control point doesn’t have a Bézier interpolation mode set. In this case, the /// - The next control point doesn’t have a Bézier interpolation mode set. In this case, the
/// tangent used for the next control point is defined as the segment connecting that control /// tangent used for the next control point is defined as the segment connecting that control
/// point and the current control point’s associated point. This is called _quadratic Bézer /// point and the current control point’s associated point. This is called _quadratic Bézer
/// interpolation_ and it kicks ass too, but a bit less than cubic. /// interpolation_ and it kicks ass too, but a bit less than cubic.
Bezier(V), Bezier(V),
/// A special Bézier interpolation using an _input tangent_ and an _output tangent_. /// A special Bézier interpolation using an _input tangent_ and an _output tangent_.
/// ///
/// With this kind of interpolation, a control point has an input tangent, which has the same role /// With this kind of interpolation, a control point has an input tangent, which has the same role
/// as the one defined by [`Interpolation::Bezier`], and an output tangent, which has the same /// as the one defined by [`Interpolation::Bezier`], and an output tangent, which has the same
/// role defined by the next key’s [`Interpolation::Bezier`] if present, normally. /// role defined by the next key’s [`Interpolation::Bezier`] if present, normally.
/// ///
/// What it means is that instead of setting the output tangent as the next key’s Bézier tangent, /// What it means is that instead of setting the output tangent as the next key’s Bézier tangent,
/// this interpolation mode allows you to manually set the output tangent. That will yield more /// this interpolation mode allows you to manually set the output tangent. That will yield more
/// control on the tangents but might generate discontinuities. Use with care. /// control on the tangents but might generate discontinuities. Use with care.
/// ///
/// Stroke Bézier interpolation is always a cubic Bézier interpolation by default. /// Stroke Bézier interpolation is always a cubic Bézier interpolation by default.
StrokeBezier(V, V), StrokeBezier(V, V),
#[doc(hidden)] #[doc(hidden)]
__NonExhaustive __NonExhaustive,
} }
impl<T, V> Default for Interpolation<T, V> { impl<T, V> Default for Interpolation<T, V> {
/// [`Interpolation::Linear`] is the default. /// [`Interpolation::Linear`] is the default.
fn default() -> Self { fn default() -> Self {
Interpolation::Linear Interpolation::Linear
} }
} }

38
src/iter.rs
View File

@ -11,34 +11,34 @@ use crate::{Key, Spline};
/// Iterator over spline keys. /// Iterator over spline keys.
/// ///
/// This iterator type is guaranteed to iterate over sorted keys. /// This iterator type is guaranteed to iterate over sorted keys.
pub struct Iter<'a, T, V> where T: 'a, V: 'a { pub struct Iter<'a, T, V>
spline: &'a Spline<T, V>, where
i: usize T: 'a,
V: 'a,
{
spline: &'a Spline<T, V>,
i: usize,
} }
impl<'a, T, V> Iterator for Iter<'a, T, V> { impl<'a, T, V> Iterator for Iter<'a, T, V> {
type Item = &'a Key<T, V>; type Item = &'a Key<T, V>;
fn next(&mut self) -> Option<Self::Item> { fn next(&mut self) -> Option<Self::Item> {
let r = self.spline.0.get(self.i); let r = self.spline.0.get(self.i);
if let Some(_) = r { if let Some(_) = r {
self.i += 1; self.i += 1;
}
r
} }
r
}
} }
impl<'a, T, V> IntoIterator for &'a Spline<T, V> { impl<'a, T, V> IntoIterator for &'a Spline<T, V> {
type Item = &'a Key<T, V>; type Item = &'a Key<T, V>;
type IntoIter = Iter<'a, T, V>; type IntoIter = Iter<'a, T, V>;
fn into_iter(self) -> Self::IntoIter { fn into_iter(self) -> Self::IntoIter {
Iter { Iter { spline: self, i: 0 }
spline: self,
i: 0
} }
}
} }

27
src/key.rs
View File

@ -6,7 +6,8 @@
//! Splines constructed with this crate have the property that it’s possible to change the //! Splines constructed with this crate have the property that it’s possible to change the
//! interpolation mode on a key-based way, allowing you to implement and encode complex curves. //! interpolation mode on a key-based way, allowing you to implement and encode complex curves.
#[cfg(feature = "serialization")] use serde_derive::{Deserialize, Serialize}; #[cfg(feature = "serialization")]
use serde_derive::{Deserialize, Serialize};
use crate::interpolation::Interpolation; use crate::interpolation::Interpolation;
@ -21,17 +22,21 @@ use crate::interpolation::Interpolation;
#[cfg_attr(feature = "serialization", derive(Deserialize, Serialize))] #[cfg_attr(feature = "serialization", derive(Deserialize, Serialize))]
#[cfg_attr(feature = "serialization", serde(rename_all = "snake_case"))] #[cfg_attr(feature = "serialization", serde(rename_all = "snake_case"))]
pub struct Key<T, V> { pub struct Key<T, V> {
/// Interpolation parameter at which the [`Key`] should be reached. /// Interpolation parameter at which the [`Key`] should be reached.
pub t: T, pub t: T,
/// Carried value. /// Carried value.
pub value: V, pub value: V,
/// Interpolation mode. /// Interpolation mode.
pub interpolation: Interpolation<T, V> pub interpolation: Interpolation<T, V>,
} }
impl<T, V> Key<T, V> { impl<T, V> Key<T, V> {
/// Create a new key. /// Create a new key.
pub fn new(t: T, value: V, interpolation: Interpolation<T, V>) -> Self { pub fn new(t: T, value: V, interpolation: Interpolation<T, V>) -> Self {
Key { t, value, interpolation } Key {
} t,
value,
interpolation,
}
}
} }

9
src/lib.rs
View File

@ -106,14 +106,17 @@
#![cfg_attr(not(feature = "std"), feature(alloc))] #![cfg_attr(not(feature = "std"), feature(alloc))]
#![cfg_attr(not(feature = "std"), feature(core_intrinsics))] #![cfg_attr(not(feature = "std"), feature(core_intrinsics))]
#[cfg(not(feature = "std"))] extern crate alloc; #[cfg(not(feature = "std"))]
extern crate alloc;
#[cfg(feature = "impl-cgmath")] mod cgmath; #[cfg(feature = "impl-cgmath")]
mod cgmath;
pub mod interpolate; pub mod interpolate;
pub mod interpolation; pub mod interpolation;
pub mod iter; pub mod iter;
pub mod key; pub mod key;
#[cfg(feature = "impl-nalgebra")] mod nalgebra; #[cfg(feature = "impl-nalgebra")]
mod nalgebra;
pub mod spline; pub mod spline;
pub use crate::interpolate::Interpolate; pub use crate::interpolate::Interpolate;

2
src/nalgebra.rs
View File

@ -4,7 +4,7 @@ use num_traits as nt;
use std::ops::Mul; use std::ops::Mul;
use crate::interpolate::{ use crate::interpolate::{
Interpolate, Linear, Additive, One, cubic_bezier_def, cubic_hermite_def, quadratic_bezier_def cubic_bezier_def, cubic_hermite_def, quadratic_bezier_def, Additive, Interpolate, Linear, One,
}; };
macro_rules! impl_interpolate_vector { macro_rules! impl_interpolate_vector {

541
src/spline.rs
View File

@ -1,11 +1,17 @@
//! Spline curves and operations. //! Spline curves and operations.
#[cfg(feature = "serialization")] use serde_derive::{Deserialize, Serialize}; #[cfg(not(feature = "std"))]
#[cfg(not(feature = "std"))] use alloc::vec::Vec; use alloc::vec::Vec;
#[cfg(feature = "std")] use std::cmp::Ordering; #[cfg(not(feature = "std"))]
#[cfg(feature = "std")] use std::ops::{Div, Mul}; use core::cmp::Ordering;
#[cfg(not(feature = "std"))] use core::ops::{Div, Mul}; #[cfg(not(feature = "std"))]
#[cfg(not(feature = "std"))] use core::cmp::Ordering; use core::ops::{Div, Mul};
#[cfg(feature = "serialization")]
use serde_derive::{Deserialize, Serialize};
#[cfg(feature = "std")]
use std::cmp::Ordering;
#[cfg(feature = "std")]
use std::ops::{Div, Mul};
use crate::interpolate::{Additive, Interpolate, One, Trigo}; use crate::interpolate::{Additive, Interpolate, One, Trigo};
use crate::interpolation::Interpolation; use crate::interpolation::Interpolation;
@ -28,237 +34,268 @@ use crate::key::Key;
pub struct Spline<T, V>(pub(crate) Vec<Key<T, V>>); pub struct Spline<T, V>(pub(crate) Vec<Key<T, V>>);
impl<T, V> Spline<T, V> { impl<T, V> Spline<T, V> {
/// Internal sort to ensure invariant of sorting keys is valid. /// Internal sort to ensure invariant of sorting keys is valid.
fn internal_sort(&mut self) where T: PartialOrd { fn internal_sort(&mut self)
self.0.sort_by(|k0, k1| k0.t.partial_cmp(&k1.t).unwrap_or(Ordering::Less)); where
} T: PartialOrd,
{
self.0
.sort_by(|k0, k1| k0.t.partial_cmp(&k1.t).unwrap_or(Ordering::Less));
}
/// Create a new spline out of keys. The keys don’t have to be sorted even though it’s recommended /// Create a new spline out of keys. The keys don’t have to be sorted even though it’s recommended
/// to provide ascending sorted ones (for performance purposes). /// to provide ascending sorted ones (for performance purposes).
pub fn from_vec(keys: Vec<Key<T, V>>) -> Self where T: PartialOrd { pub fn from_vec(keys: Vec<Key<T, V>>) -> Self
let mut spline = Spline(keys); where
spline.internal_sort(); T: PartialOrd,
spline {
} let mut spline = Spline(keys);
spline.internal_sort();
spline
}
/// Create a new spline by consuming an `Iterater<Item = Key<T>>`. They keys don’t have to be /// Create a new spline by consuming an `Iterater<Item = Key<T>>`. They keys don’t have to be
/// sorted. /// sorted.
/// ///
/// # Note on iterators /// # Note on iterators
/// ///
/// It’s valid to use any iterator that implements `Iterator<Item = Key<T>>`. However, you should /// It’s valid to use any iterator that implements `Iterator<Item = Key<T>>`. However, you should
/// use [`Spline::from_vec`] if you are passing a [`Vec`]. /// use [`Spline::from_vec`] if you are passing a [`Vec`].
pub fn from_iter<I>(iter: I) -> Self where I: Iterator<Item = Key<T, V>>, T: PartialOrd { pub fn from_iter<I>(iter: I) -> Self
Self::from_vec(iter.collect()) where
} I: Iterator<Item = Key<T, V>>,
T: PartialOrd,
{
Self::from_vec(iter.collect())
}
/// Retrieve the keys of a spline. /// Retrieve the keys of a spline.
pub fn keys(&self) -> &[Key<T, V>] { pub fn keys(&self) -> &[Key<T, V>] {
&self.0 &self.0
} }
/// Number of keys. /// Number of keys.
#[inline(always)] #[inline(always)]
pub fn len(&self) -> usize { pub fn len(&self) -> usize {
self.0.len() self.0.len()
} }
/// Check whether the spline has no key. /// Check whether the spline has no key.
#[inline(always)] #[inline(always)]
pub fn is_empty(&self) -> bool { pub fn is_empty(&self) -> bool {
self.0.is_empty() self.0.is_empty()
} }
/// Sample a spline at a given time, returning the interpolated value along with its associated /// Sample a spline at a given time, returning the interpolated value along with its associated
/// key. /// key.
/// ///
/// The current implementation, based on immutability, cannot perform in constant time. This means /// The current implementation, based on immutability, cannot perform in constant time. This means
/// that sampling’s processing complexity is currently *O(log n)*. It’s possible to achieve *O(1)* /// that sampling’s processing complexity is currently *O(log n)*. It’s possible to achieve *O(1)*
/// performance by using a slightly different spline type. If you are interested by this feature, /// performance by using a slightly different spline type. If you are interested by this feature,
/// an implementation for a dedicated type is foreseen yet not started yet. /// an implementation for a dedicated type is foreseen yet not started yet.
/// ///
/// # Return /// # Return
/// ///
/// `None` if you try to sample a value at a time that has no key associated with. That can also /// `None` if you try to sample a value at a time that has no key associated with. That can also
/// happen if you try to sample between two keys with a specific interpolation mode that makes the /// happen if you try to sample between two keys with a specific interpolation mode that makes the
/// sampling impossible. For instance, [`Interpolation::CatmullRom`] requires *four* keys. If /// sampling impossible. For instance, [`Interpolation::CatmullRom`] requires *four* keys. If
/// you’re near the beginning of the spline or its end, ensure you have enough keys around to make /// you’re near the beginning of the spline or its end, ensure you have enough keys around to make
/// the sampling. /// the sampling.
pub fn sample_with_key(&self, t: T) -> Option<(V, &Key<T, V>, Option<&Key<T, V>>)> 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, where
V: Additive + Interpolate<T> { T: Additive + One + Trigo + Mul<T, Output = T> + Div<T, Output = T> + PartialOrd,
let keys = &self.0; V: Additive + Interpolate<T>,
let i = search_lower_cp(keys, t)?; {
let cp0 = &keys[i]; let keys = &self.0;
let i = search_lower_cp(keys, t)?;
let cp0 = &keys[i];
match cp0.interpolation { match cp0.interpolation {
Interpolation::Step(threshold) => { Interpolation::Step(threshold) => {
let cp1 = &keys[i + 1]; let cp1 = &keys[i + 1];
let nt = normalize_time(t, cp0, cp1); let nt = normalize_time(t, cp0, cp1);
let value = if nt < threshold { cp0.value } else { cp1.value }; let value = if nt < threshold { cp0.value } else { cp1.value };
Some((value, cp0, Some(cp1))) Some((value, cp0, Some(cp1)))
}
Interpolation::Linear => {
let cp1 = &keys[i + 1];
let nt = normalize_time(t, cp0, cp1);
let value = Interpolate::lerp(cp0.value, cp1.value, nt);
Some((value, cp0, Some(cp1)))
}
Interpolation::Cosine => {
let two_t = T::one() + T::one();
let cp1 = &keys[i + 1];
let nt = normalize_time(t, cp0, cp1);
let cos_nt = (T::one() - (nt * T::pi()).cos()) / two_t;
let value = Interpolate::lerp(cp0.value, cp1.value, cos_nt);
Some((value, cp0, Some(cp1)))
}
Interpolation::CatmullRom => {
// We need at least four points for Catmull Rom; ensure we have them, otherwise, return
// None.
if i == 0 || i >= keys.len() - 2 {
None
} else {
let cp1 = &keys[i + 1];
let cpm0 = &keys[i - 1];
let cpm1 = &keys[i + 2];
let nt = normalize_time(t, cp0, cp1);
let value = Interpolate::cubic_hermite((cpm0.value, cpm0.t), (cp0.value, cp0.t), (cp1.value, cp1.t), (cpm1.value, cpm1.t), nt);
Some((value, cp0, Some(cp1)))
}
}
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 =
match cp1.interpolation {
Interpolation::Bezier(v) => {
Interpolate::cubic_bezier(cp0.value, u, cp1.value + cp1.value - v, cp1.value, nt)
} }
Interpolation::StrokeBezier(v, _) => { Interpolation::Linear => {
Interpolate::cubic_bezier(cp0.value, u, v, cp1.value, nt) let cp1 = &keys[i + 1];
let nt = normalize_time(t, cp0, cp1);
let value = Interpolate::lerp(cp0.value, cp1.value, nt);
Some((value, cp0, Some(cp1)))
} }
_ => Interpolate::quadratic_bezier(cp0.value, u, cp1.value, nt) Interpolation::Cosine => {
}; let two_t = T::one() + T::one();
let cp1 = &keys[i + 1];
let nt = normalize_time(t, cp0, cp1);
let cos_nt = (T::one() - (nt * T::pi()).cos()) / two_t;
let value = Interpolate::lerp(cp0.value, cp1.value, cos_nt);
Some((value, cp0, Some(cp1))) Some((value, cp0, Some(cp1)))
} }
Interpolation::__NonExhaustive => unreachable!(), Interpolation::CatmullRom => {
} // We need at least four points for Catmull Rom; ensure we have them, otherwise, return
} // None.
if i == 0 || i >= keys.len() - 2 {
None
} else {
let cp1 = &keys[i + 1];
let cpm0 = &keys[i - 1];
let cpm1 = &keys[i + 2];
let nt = normalize_time(t, cp0, cp1);
let value = Interpolate::cubic_hermite(
(cpm0.value, cpm0.t),
(cp0.value, cp0.t),
(cp1.value, cp1.t),
(cpm1.value, cpm1.t),
nt,
);
/// Sample a spline at a given time. Some((value, cp0, Some(cp1)))
/// }
pub fn sample(&self, t: T) -> Option<V> }
where T: Additive + One + Trigo + Mul<T, Output = T> + Div<T, Output = T> + PartialOrd,
V: Additive + Interpolate<T> {
self.sample_with_key(t).map(|(v, _, _)| v)
}
/// Sample a spline at a given time with clamping, returning the interpolated value along with its Interpolation::Bezier(u) | Interpolation::StrokeBezier(_, u) => {
/// associated key. // We need to check the next control point to see whether we want quadratic or cubic Bezier.
/// let cp1 = &keys[i + 1];
/// # Return let nt = normalize_time(t, cp0, cp1);
///
/// If you sample before the first key or after the last one, return the first key or the last
/// one, respectively. Otherwise, behave the same way as [`Spline::sample`].
///
/// # Error
///
/// 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: Additive + Interpolate<T> {
if self.0.is_empty() {
return None;
}
self.sample_with_key(t).or_else(move || { let value = match cp1.interpolation {
let first = self.0.first().unwrap(); Interpolation::Bezier(v) => Interpolate::cubic_bezier(
if t <= first.t { cp0.value,
let second = if self.0.len() >= 2 { Some(&self.0[1]) } else { None }; u,
Some((first.value, &first, second)) cp1.value + cp1.value - v,
} else { cp1.value,
let last = self.0.last().unwrap(); nt,
),
if t >= last.t { Interpolation::StrokeBezier(v, _) => {
Some((last.value, &last, None)) Interpolate::cubic_bezier(cp0.value, u, v, cp1.value, nt)
} else { }
None
_ => Interpolate::quadratic_bezier(cp0.value, u, cp1.value, nt),
};
Some((value, cp0, Some(cp1)))
}
Interpolation::__NonExhaustive => unreachable!(),
} }
}
})
}
/// 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: Additive + Interpolate<T> {
self.clamped_sample_with_key(t).map(|(v, _, _)| v)
}
/// Add a key into the spline.
pub fn add(&mut self, key: Key<T, V>) where T: PartialOrd {
self.0.push(key);
self.internal_sort();
}
/// Remove a key from the spline.
pub fn remove(&mut self, index: usize) -> Option<Key<T, V>> {
if index >= self.0.len() {
None
} else {
Some(self.0.remove(index))
} }
}
/// Update a key and return the key already present. /// Sample a spline at a given time.
/// ///
/// The key is updated — if present — with the provided function. pub fn sample(&self, t: T) -> Option<V>
/// where
/// # Notes T: Additive + One + Trigo + Mul<T, Output = T> + Div<T, Output = T> + PartialOrd,
/// V: Additive + Interpolate<T>,
/// That function makes sense only if you want to change the interpolator (i.e. [`Key::t`]) of {
/// your key. If you just want to change the interpolation mode or the carried value, consider self.sample_with_key(t).map(|(v, _, _)| v)
/// using the [`Spline::get_mut`] method instead as it will be way faster. }
pub fn replace<F>(
&mut self,
index: usize,
f: F
) -> Option<Key<T, V>>
where
F: FnOnce(&Key<T, V>) -> Key<T, V>,
T: PartialOrd
{
let key = self.remove(index)?;
self.add(f(&key));
Some(key)
}
/// Get a key at a given index. /// Sample a spline at a given time with clamping, returning the interpolated value along with its
pub fn get(&self, index: usize) -> Option<&Key<T, V>> { /// associated key.
self.0.get(index) ///
} /// # Return
///
/// If you sample before the first key or after the last one, return the first key or the last
/// one, respectively. Otherwise, behave the same way as [`Spline::sample`].
///
/// # Error
///
/// 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: Additive + Interpolate<T>,
{
if self.0.is_empty() {
return None;
}
/// Mutably get a key at a given index. self.sample_with_key(t).or_else(move || {
pub fn get_mut(&mut self, index: usize) -> Option<KeyMut<T, V>> { let first = self.0.first().unwrap();
self.0.get_mut(index).map(|key| KeyMut { if t <= first.t {
value: &mut key.value, let second = if self.0.len() >= 2 {
interpolation: &mut key.interpolation Some(&self.0[1])
}) } else {
} None
};
Some((first.value, &first, second))
} else {
let last = self.0.last().unwrap();
if t >= last.t {
Some((last.value, &last, None))
} else {
None
}
}
})
}
/// 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: Additive + Interpolate<T>,
{
self.clamped_sample_with_key(t).map(|(v, _, _)| v)
}
/// Add a key into the spline.
pub fn add(&mut self, key: Key<T, V>)
where
T: PartialOrd,
{
self.0.push(key);
self.internal_sort();
}
/// Remove a key from the spline.
pub fn remove(&mut self, index: usize) -> Option<Key<T, V>> {
if index >= self.0.len() {
None
} else {
Some(self.0.remove(index))
}
}
/// Update a key and return the key already present.
///
/// The key is updated — if present — with the provided function.
///
/// # Notes
///
/// That function makes sense only if you want to change the interpolator (i.e. [`Key::t`]) of
/// your key. If you just want to change the interpolation mode or the carried value, consider
/// using the [`Spline::get_mut`] method instead as it will be way faster.
pub fn replace<F>(&mut self, index: usize, f: F) -> Option<Key<T, V>>
where
F: FnOnce(&Key<T, V>) -> Key<T, V>,
T: PartialOrd,
{
let key = self.remove(index)?;
self.add(f(&key));
Some(key)
}
/// Get a key at a given index.
pub fn get(&self, index: usize) -> Option<&Key<T, V>> {
self.0.get(index)
}
/// Mutably get a key at a given index.
pub fn get_mut(&mut self, index: usize) -> Option<KeyMut<T, V>> {
self.0.get_mut(index).map(|key| KeyMut {
value: &mut key.value,
interpolation: &mut key.interpolation,
})
}
} }
/// A mutable [`Key`]. /// A mutable [`Key`].
@ -267,52 +304,54 @@ impl<T, V> Spline<T, V> {
/// interpolator value as it would invalidate the internal structure of the [`Spline`]. If you /// interpolator value as it would invalidate the internal structure of the [`Spline`]. If you
/// want to achieve this, you’re advised to use [`Spline::replace`]. /// want to achieve this, you’re advised to use [`Spline::replace`].
pub struct KeyMut<'a, T, V> { pub struct KeyMut<'a, T, V> {
/// Carried value. /// Carried value.
pub value: &'a mut V, pub value: &'a mut V,
/// Interpolation mode to use for that key. /// Interpolation mode to use for that key.
pub interpolation: &'a mut Interpolation<T, V>, pub interpolation: &'a mut Interpolation<T, V>,
} }
// Normalize a time ([0;1]) given two control points. // Normalize a time ([0;1]) given two control points.
#[inline(always)] #[inline(always)]
pub(crate) fn normalize_time<T, V>( pub(crate) fn normalize_time<T, V>(t: T, cp: &Key<T, V>, cp1: &Key<T, V>) -> T
t: T, where
cp: &Key<T, V>, T: Additive + Div<T, Output = T> + PartialEq,
cp1: &Key<T, V> {
) -> T where T: Additive + Div<T, Output = T> + PartialEq { assert!(cp1.t != cp.t, "overlapping keys");
assert!(cp1.t != cp.t, "overlapping keys"); (t - cp.t) / (cp1.t - cp.t)
(t - cp.t) / (cp1.t - cp.t)
} }
// Find the lower control point corresponding to a given time. // Find the lower control point corresponding to a given time.
fn search_lower_cp<T, V>(cps: &[Key<T, V>], t: T) -> Option<usize> where T: PartialOrd { fn search_lower_cp<T, V>(cps: &[Key<T, V>], t: T) -> Option<usize>
let mut i = 0; where
let len = cps.len(); T: PartialOrd,
{
let mut i = 0;
let len = cps.len();
if len < 2 { if len < 2 {
return None;
}
loop {
let cp = &cps[i];
let cp1 = &cps[i+1];
if t >= cp1.t {
if i >= len - 2 {
return None; return None;
}
i += 1;
} else if t < cp.t {
if i == 0 {
return None;
}
i -= 1;
} else {
break; // found
} }
}
Some(i) loop {
let cp = &cps[i];
let cp1 = &cps[i + 1];
if t >= cp1.t {
if i >= len - 2 {
return None;
}
i += 1;
} else if t < cp.t {
if i == 0 {
return None;
}
i -= 1;
} else {
break; // found
}
}
Some(i)
} }

334
tests/mod.rs
View File

@ -1,245 +1,255 @@
use splines::{Interpolation, Key, Spline}; use splines::{Interpolation, Key, Spline};
#[cfg(feature = "cgmath")] use cgmath as cg; #[cfg(feature = "cgmath")]
#[cfg(feature = "nalgebra")] use nalgebra as na; use cgmath as cg;
#[cfg(feature = "nalgebra")]
use nalgebra as na;
#[test] #[test]
fn step_interpolation_f32() { fn step_interpolation_f32() {
let start = Key::new(0., 0., Interpolation::Step(0.)); let start = Key::new(0., 0., Interpolation::Step(0.));
let end = Key::new(1., 10., Interpolation::default()); let end = Key::new(1., 10., Interpolation::default());
let spline = Spline::<f32, _>::from_vec(vec![start, end]); let spline = Spline::<f32, _>::from_vec(vec![start, end]);
assert_eq!(spline.sample(0.), Some(10.)); assert_eq!(spline.sample(0.), Some(10.));
assert_eq!(spline.sample(0.1), Some(10.)); assert_eq!(spline.sample(0.1), Some(10.));
assert_eq!(spline.sample(0.2), Some(10.)); assert_eq!(spline.sample(0.2), Some(10.));
assert_eq!(spline.sample(0.5), Some(10.)); assert_eq!(spline.sample(0.5), Some(10.));
assert_eq!(spline.sample(0.9), Some(10.)); assert_eq!(spline.sample(0.9), Some(10.));
assert_eq!(spline.sample(1.), None); assert_eq!(spline.sample(1.), None);
assert_eq!(spline.clamped_sample(1.), Some(10.)); assert_eq!(spline.clamped_sample(1.), Some(10.));
assert_eq!(spline.sample_with_key(0.2), Some((10., &start, Some(&end)))); assert_eq!(spline.sample_with_key(0.2), Some((10., &start, Some(&end))));
assert_eq!(spline.clamped_sample_with_key(1.), Some((10., &end, None))); assert_eq!(spline.clamped_sample_with_key(1.), Some((10., &end, None)));
} }
#[test] #[test]
fn step_interpolation_f64() { fn step_interpolation_f64() {
let start = Key::new(0., 0., Interpolation::Step(0.)); let start = Key::new(0., 0., Interpolation::Step(0.));
let end = Key::new(1., 10., Interpolation::default()); let end = Key::new(1., 10., Interpolation::default());
let spline = Spline::<f64, _>::from_vec(vec![start, end]); let spline = Spline::<f64, _>::from_vec(vec![start, end]);
assert_eq!(spline.sample(0.), Some(10.)); assert_eq!(spline.sample(0.), Some(10.));
assert_eq!(spline.sample(0.1), Some(10.)); assert_eq!(spline.sample(0.1), Some(10.));
assert_eq!(spline.sample(0.2), Some(10.)); assert_eq!(spline.sample(0.2), Some(10.));
assert_eq!(spline.sample(0.5), Some(10.)); assert_eq!(spline.sample(0.5), Some(10.));
assert_eq!(spline.sample(0.9), Some(10.)); assert_eq!(spline.sample(0.9), Some(10.));
assert_eq!(spline.sample(1.), None); assert_eq!(spline.sample(1.), None);
assert_eq!(spline.clamped_sample(1.), Some(10.)); assert_eq!(spline.clamped_sample(1.), Some(10.));
assert_eq!(spline.sample_with_key(0.2), Some((10., &start, Some(&end)))); assert_eq!(spline.sample_with_key(0.2), Some((10., &start, Some(&end))));
assert_eq!(spline.clamped_sample_with_key(1.), Some((10., &end, None))); assert_eq!(spline.clamped_sample_with_key(1.), Some((10., &end, None)));
} }
#[test] #[test]
fn step_interpolation_0_5() { fn step_interpolation_0_5() {
let start = Key::new(0., 0., Interpolation::Step(0.5)); let start = Key::new(0., 0., Interpolation::Step(0.5));
let end = Key::new(1., 10., Interpolation::default()); let end = Key::new(1., 10., Interpolation::default());
let spline = Spline::from_vec(vec![start, end]); let spline = Spline::from_vec(vec![start, end]);
assert_eq!(spline.sample(0.), Some(0.)); assert_eq!(spline.sample(0.), Some(0.));
assert_eq!(spline.sample(0.1), Some(0.)); assert_eq!(spline.sample(0.1), Some(0.));
assert_eq!(spline.sample(0.2), Some(0.)); assert_eq!(spline.sample(0.2), Some(0.));
assert_eq!(spline.sample(0.5), Some(10.)); assert_eq!(spline.sample(0.5), Some(10.));
assert_eq!(spline.sample(0.9), Some(10.)); assert_eq!(spline.sample(0.9), Some(10.));
assert_eq!(spline.sample(1.), None); assert_eq!(spline.sample(1.), None);
assert_eq!(spline.clamped_sample(1.), Some(10.)); assert_eq!(spline.clamped_sample(1.), Some(10.));
} }
#[test] #[test]
fn step_interpolation_0_75() { fn step_interpolation_0_75() {
let start = Key::new(0., 0., Interpolation::Step(0.75)); let start = Key::new(0., 0., Interpolation::Step(0.75));
let end = Key::new(1., 10., Interpolation::default()); let end = Key::new(1., 10., Interpolation::default());
let spline = Spline::from_vec(vec![start, end]); let spline = Spline::from_vec(vec![start, end]);
assert_eq!(spline.sample(0.), Some(0.)); assert_eq!(spline.sample(0.), Some(0.));
assert_eq!(spline.sample(0.1), Some(0.)); assert_eq!(spline.sample(0.1), Some(0.));
assert_eq!(spline.sample(0.2), Some(0.)); assert_eq!(spline.sample(0.2), Some(0.));
assert_eq!(spline.sample(0.5), Some(0.)); assert_eq!(spline.sample(0.5), Some(0.));
assert_eq!(spline.sample(0.9), Some(10.)); assert_eq!(spline.sample(0.9), Some(10.));
assert_eq!(spline.sample(1.), None); assert_eq!(spline.sample(1.), None);
assert_eq!(spline.clamped_sample(1.), Some(10.)); assert_eq!(spline.clamped_sample(1.), Some(10.));
} }
#[test] #[test]
fn step_interpolation_1() { fn step_interpolation_1() {
let start = Key::new(0., 0., Interpolation::Step(1.)); let start = Key::new(0., 0., Interpolation::Step(1.));
let end = Key::new(1., 10., Interpolation::default()); let end = Key::new(1., 10., Interpolation::default());
let spline = Spline::from_vec(vec![start, end]); let spline = Spline::from_vec(vec![start, end]);
assert_eq!(spline.sample(0.), Some(0.)); assert_eq!(spline.sample(0.), Some(0.));
assert_eq!(spline.sample(0.1), Some(0.)); assert_eq!(spline.sample(0.1), Some(0.));
assert_eq!(spline.sample(0.2), Some(0.)); assert_eq!(spline.sample(0.2), Some(0.));
assert_eq!(spline.sample(0.5), Some(0.)); assert_eq!(spline.sample(0.5), Some(0.));
assert_eq!(spline.sample(0.9), Some(0.)); assert_eq!(spline.sample(0.9), Some(0.));
assert_eq!(spline.sample(1.), None); assert_eq!(spline.sample(1.), None);
assert_eq!(spline.clamped_sample(1.), Some(10.)); assert_eq!(spline.clamped_sample(1.), Some(10.));
} }
#[test] #[test]
fn linear_interpolation() { fn linear_interpolation() {
let start = Key::new(0., 0., Interpolation::Linear); let start = Key::new(0., 0., Interpolation::Linear);
let end = Key::new(1., 10., Interpolation::default()); let end = Key::new(1., 10., Interpolation::default());
let spline = Spline::from_vec(vec![start, end]); let spline = Spline::from_vec(vec![start, end]);
assert_eq!(spline.sample(0.), Some(0.)); assert_eq!(spline.sample(0.), Some(0.));
assert_eq!(spline.sample(0.1), Some(1.)); assert_eq!(spline.sample(0.1), Some(1.));
assert_eq!(spline.sample(0.2), Some(2.)); assert_eq!(spline.sample(0.2), Some(2.));
assert_eq!(spline.sample(0.5), Some(5.)); assert_eq!(spline.sample(0.5), Some(5.));
assert_eq!(spline.sample(0.9), Some(9.)); assert_eq!(spline.sample(0.9), Some(9.));
assert_eq!(spline.sample(1.), None); assert_eq!(spline.sample(1.), None);
assert_eq!(spline.clamped_sample(1.), Some(10.)); assert_eq!(spline.clamped_sample(1.), Some(10.));
} }
#[test] #[test]
fn linear_interpolation_several_keys() { fn linear_interpolation_several_keys() {
let start = Key::new(0., 0., Interpolation::Linear); let start = Key::new(0., 0., Interpolation::Linear);
let k1 = Key::new(1., 5., Interpolation::Linear); let k1 = Key::new(1., 5., Interpolation::Linear);
let k2 = Key::new(2., 0., Interpolation::Linear); let k2 = Key::new(2., 0., Interpolation::Linear);
let k3 = Key::new(3., 1., Interpolation::Linear); let k3 = Key::new(3., 1., Interpolation::Linear);
let k4 = Key::new(10., 2., Interpolation::Linear); let k4 = Key::new(10., 2., Interpolation::Linear);
let end = Key::new(11., 4., Interpolation::default()); let end = Key::new(11., 4., Interpolation::default());
let spline = Spline::from_vec(vec![start, k1, k2, k3, k4, end]); let spline = Spline::from_vec(vec![start, k1, k2, k3, k4, end]);
assert_eq!(spline.sample(0.), Some(0.)); assert_eq!(spline.sample(0.), Some(0.));
assert_eq!(spline.sample(0.1), Some(0.5)); assert_eq!(spline.sample(0.1), Some(0.5));
assert_eq!(spline.sample(0.2), Some(1.)); assert_eq!(spline.sample(0.2), Some(1.));
assert_eq!(spline.sample(0.5), Some(2.5)); assert_eq!(spline.sample(0.5), Some(2.5));
assert_eq!(spline.sample(0.9), Some(4.5)); assert_eq!(spline.sample(0.9), Some(4.5));
assert_eq!(spline.sample(1.), Some(5.)); assert_eq!(spline.sample(1.), Some(5.));
assert_eq!(spline.sample(1.5), Some(2.5)); assert_eq!(spline.sample(1.5), Some(2.5));
assert_eq!(spline.sample(2.), Some(0.)); assert_eq!(spline.sample(2.), Some(0.));
assert_eq!(spline.sample(2.75), Some(0.75)); assert_eq!(spline.sample(2.75), Some(0.75));
assert_eq!(spline.sample(3.), Some(1.)); assert_eq!(spline.sample(3.), Some(1.));
assert_eq!(spline.sample(6.5), Some(1.5)); assert_eq!(spline.sample(6.5), Some(1.5));
assert_eq!(spline.sample(10.), Some(2.)); assert_eq!(spline.sample(10.), Some(2.));
assert_eq!(spline.clamped_sample(11.), Some(4.)); assert_eq!(spline.clamped_sample(11.), Some(4.));
} }
#[test] #[test]
fn several_interpolations_several_keys() { fn several_interpolations_several_keys() {
let start = Key::new(0., 0., Interpolation::Step(0.5)); let start = Key::new(0., 0., Interpolation::Step(0.5));
let k1 = Key::new(1., 5., Interpolation::Linear); let k1 = Key::new(1., 5., Interpolation::Linear);
let k2 = Key::new(2., 0., Interpolation::Step(0.1)); let k2 = Key::new(2., 0., Interpolation::Step(0.1));
let k3 = Key::new(3., 1., Interpolation::Linear); let k3 = Key::new(3., 1., Interpolation::Linear);
let k4 = Key::new(10., 2., Interpolation::Linear); let k4 = Key::new(10., 2., Interpolation::Linear);
let end = Key::new(11., 4., Interpolation::default()); let end = Key::new(11., 4., Interpolation::default());
let spline = Spline::from_vec(vec![start, k1, k2, k3, k4, end]); let spline = Spline::from_vec(vec![start, k1, k2, k3, k4, end]);
assert_eq!(spline.sample(0.), Some(0.)); assert_eq!(spline.sample(0.), Some(0.));
assert_eq!(spline.sample(0.1), Some(0.)); assert_eq!(spline.sample(0.1), Some(0.));
assert_eq!(spline.sample(0.2), Some(0.)); assert_eq!(spline.sample(0.2), Some(0.));
assert_eq!(spline.sample(0.5), Some(5.)); assert_eq!(spline.sample(0.5), Some(5.));
assert_eq!(spline.sample(0.9), Some(5.)); assert_eq!(spline.sample(0.9), Some(5.));
assert_eq!(spline.sample(1.), Some(5.)); assert_eq!(spline.sample(1.), Some(5.));
assert_eq!(spline.sample(1.5), Some(2.5)); assert_eq!(spline.sample(1.5), Some(2.5));
assert_eq!(spline.sample(2.), Some(0.)); assert_eq!(spline.sample(2.), Some(0.));
assert_eq!(spline.sample(2.05), Some(0.)); assert_eq!(spline.sample(2.05), Some(0.));
assert_eq!(spline.sample(2.099), Some(0.)); assert_eq!(spline.sample(2.099), Some(0.));
assert_eq!(spline.sample(2.75), Some(1.)); assert_eq!(spline.sample(2.75), Some(1.));
assert_eq!(spline.sample(3.), Some(1.)); assert_eq!(spline.sample(3.), Some(1.));
assert_eq!(spline.sample(6.5), Some(1.5)); assert_eq!(spline.sample(6.5), Some(1.5));
assert_eq!(spline.sample(10.), Some(2.)); assert_eq!(spline.sample(10.), Some(2.));
assert_eq!(spline.clamped_sample(11.), Some(4.)); assert_eq!(spline.clamped_sample(11.), Some(4.));
} }
#[cfg(feature = "cgmath")] #[cfg(feature = "cgmath")]
#[test] #[test]
fn stroke_bezier_straight() { fn stroke_bezier_straight() {
use float_cmp::approx_eq; use float_cmp::approx_eq;
let keys = vec![ 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(
Key::new(5.0, cg::Vector2::new(5., 1.), Interpolation::StrokeBezier(cg::Vector2::new(5., 1.), cg::Vector2::new(5., 1.))) 0.0,
]; cg::Vector2::new(0., 1.),
let spline = Spline::from_vec(keys); 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(0.0).unwrap().y, 1.));
assert!(approx_eq!(f32, spline.clamped_sample(1.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(2.0).unwrap().y, 1.));
assert!(approx_eq!(f32, spline.clamped_sample(3.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(4.0).unwrap().y, 1.));
assert!(approx_eq!(f32, spline.clamped_sample(5.0).unwrap().y, 1.)); assert!(approx_eq!(f32, spline.clamped_sample(5.0).unwrap().y, 1.));
} }
#[cfg(feature = "cgmath")] #[cfg(feature = "cgmath")]
#[test] #[test]
fn cgmath_vector_interpolation() { fn cgmath_vector_interpolation() {
use splines::Interpolate; use splines::Interpolate;
let start = cg::Vector2::new(0.0, 0.0); let start = cg::Vector2::new(0.0, 0.0);
let mid = cg::Vector2::new(0.5, 0.5); let mid = cg::Vector2::new(0.5, 0.5);
let end = cg::Vector2::new(1.0, 1.0); let end = cg::Vector2::new(1.0, 1.0);
assert_eq!(Interpolate::lerp(start, end, 0.0), start); assert_eq!(Interpolate::lerp(start, end, 0.0), start);
assert_eq!(Interpolate::lerp(start, end, 1.0), end); assert_eq!(Interpolate::lerp(start, end, 1.0), end);
assert_eq!(Interpolate::lerp(start, end, 0.5), mid); assert_eq!(Interpolate::lerp(start, end, 0.5), mid);
} }
#[cfg(feature = "nalgebra")] #[cfg(feature = "nalgebra")]
#[test] #[test]
fn nalgebra_vector_interpolation() { fn nalgebra_vector_interpolation() {
use splines::Interpolate; use splines::Interpolate;
let start = na::Vector2::new(0.0, 0.0); let start = na::Vector2::new(0.0, 0.0);
let mid = na::Vector2::new(0.5, 0.5); let mid = na::Vector2::new(0.5, 0.5);
let end = na::Vector2::new(1.0, 1.0); let end = na::Vector2::new(1.0, 1.0);
assert_eq!(Interpolate::lerp(start, end, 0.0), start); assert_eq!(Interpolate::lerp(start, end, 0.0), start);
assert_eq!(Interpolate::lerp(start, end, 1.0), end); assert_eq!(Interpolate::lerp(start, end, 1.0), end);
assert_eq!(Interpolate::lerp(start, end, 0.5), mid); assert_eq!(Interpolate::lerp(start, end, 0.5), mid);
} }
#[test] #[test]
fn add_key_empty() { fn add_key_empty() {
let mut spline: Spline<f32, f32> = Spline::from_vec(vec![]); let mut spline: Spline<f32, f32> = Spline::from_vec(vec![]);
spline.add(Key::new(0., 0., Interpolation::Linear)); spline.add(Key::new(0., 0., Interpolation::Linear));
assert_eq!(spline.keys(), &[Key::new(0., 0., Interpolation::Linear)]); assert_eq!(spline.keys(), &[Key::new(0., 0., Interpolation::Linear)]);
} }
#[test] #[test]
fn add_key() { fn add_key() {
let start = Key::new(0., 0., Interpolation::Step(0.5)); let start = Key::new(0., 0., Interpolation::Step(0.5));
let k1 = Key::new(1., 5., Interpolation::Linear); let k1 = Key::new(1., 5., Interpolation::Linear);
let k2 = Key::new(2., 0., Interpolation::Step(0.1)); let k2 = Key::new(2., 0., Interpolation::Step(0.1));
let k3 = Key::new(3., 1., Interpolation::Linear); let k3 = Key::new(3., 1., Interpolation::Linear);
let k4 = Key::new(10., 2., Interpolation::Linear); let k4 = Key::new(10., 2., Interpolation::Linear);
let end = Key::new(11., 4., Interpolation::default()); let end = Key::new(11., 4., Interpolation::default());
let new = Key::new(2.4, 40., Interpolation::Linear); let new = Key::new(2.4, 40., Interpolation::Linear);
let mut spline = Spline::from_vec(vec![start, k1, k2.clone(), k3, k4, end]); let mut spline = Spline::from_vec(vec![start, k1, k2.clone(), k3, k4, end]);
assert_eq!(spline.keys(), &[start, k1, k2, k3, k4, end]); assert_eq!(spline.keys(), &[start, k1, k2, k3, k4, end]);
spline.add(new); spline.add(new);
assert_eq!(spline.keys(), &[start, k1, k2, new, k3, k4, end]); assert_eq!(spline.keys(), &[start, k1, k2, new, k3, k4, end]);
} }
#[test] #[test]
fn remove_element_empty() { fn remove_element_empty() {
let mut spline: Spline<f32, f32> = Spline::from_vec(vec![]); let mut spline: Spline<f32, f32> = Spline::from_vec(vec![]);
let removed = spline.remove(0); let removed = spline.remove(0);
assert_eq!(removed, None); assert_eq!(removed, None);
assert!(spline.is_empty()); assert!(spline.is_empty());
} }
#[test] #[test]
fn remove_element() { fn remove_element() {
let start = Key::new(0., 0., Interpolation::Step(0.5)); let start = Key::new(0., 0., Interpolation::Step(0.5));
let k1 = Key::new(1., 5., Interpolation::Linear); let k1 = Key::new(1., 5., Interpolation::Linear);
let k2 = Key::new(2., 0., Interpolation::Step(0.1)); let k2 = Key::new(2., 0., Interpolation::Step(0.1));
let k3 = Key::new(3., 1., Interpolation::Linear); let k3 = Key::new(3., 1., Interpolation::Linear);
let k4 = Key::new(10., 2., Interpolation::Linear); let k4 = Key::new(10., 2., Interpolation::Linear);
let end = Key::new(11., 4., Interpolation::default()); let end = Key::new(11., 4., Interpolation::default());
let mut spline = Spline::from_vec(vec![start, k1, k2.clone(), k3, k4, end]); let mut spline = Spline::from_vec(vec![start, k1, k2.clone(), k3, k4, end]);
let removed = spline.remove(2); let removed = spline.remove(2);
assert_eq!(removed, Some(k2)); assert_eq!(removed, Some(k2));
assert_eq!(spline.len(), 5); assert_eq!(spline.len(), 5);
} }