Struct Slerp 

pub struct Slerp { /* private fields */ }

Slerp represents a spherical linear interpolation between two rotations.

Spherical linear interpolation provides smooth interpolation between two rotations along the shortest arc on the hypersphere of unit quaternions.

Examples

use scirs2_spatial::transform::{Rotation, Slerp};
use scirs2_core::ndarray::array;
use std::f64::consts::PI;

// Create two rotations to interpolate between
let rot1 = Rotation::from_euler(&array![0.0, 0.0, 0.0].view(), "xyz").unwrap();
let rot2 = Rotation::from_euler(&array![0.0, 0.0, PI/2.0].view(), "xyz").unwrap();

// Create a Slerp interpolator
let slerp = Slerp::new(rot1, rot2).unwrap();

// Get the interpolated rotation at t=0.5 (halfway between rot1 and rot2)
let rot_half = slerp.interpolate(0.5);

// Apply the rotation to a point
let point = array![1.0, 0.0, 0.0];
let rotated = rot_half.apply(&point.view()).unwrap();
// Should be approximately [std::f64::consts::FRAC_1_SQRT_2, std::f64::consts::FRAC_1_SQRT_2, 0.0]

Implementations

impl Slerp

pub fn new(start: Rotation, end: Rotation) -> SpatialResult<Self>

Create a new Slerp interpolator between two rotations

Arguments

• start - The starting rotation
• end - The ending rotation

Returns

A SpatialResult containing the Slerp object if valid, or an error if invalid

Examples

use scirs2_spatial::transform::{Rotation, Slerp};
use scirs2_core::ndarray::array;
use std::f64::consts::PI;

let rot1 = Rotation::identity();
let rot2 = Rotation::from_euler(&array![0.0, 0.0, PI/2.0].view(), "xyz").unwrap();
let slerp = Slerp::new(rot1, rot2).unwrap();

pub fn interpolate(&self, t: f64) -> Rotation

Interpolate between the start and end rotations

Arguments

• t - The interpolation parameter (0.0 = start, 1.0 = end)

Returns

The interpolated rotation

Examples

use scirs2_spatial::transform::{Rotation, Slerp};
use scirs2_core::ndarray::array;
use std::f64::consts::PI;

let rot1 = Rotation::identity();
let rot2 = Rotation::from_euler(&array![0.0, 0.0, PI].view(), "xyz").unwrap();
let slerp = Slerp::new(rot1, rot2).unwrap();

// Get rotation at t=0.25 (25% from rot1 to rot2)
let rot_25 = slerp.interpolate(0.25);

// Get rotation at t=0.5 (halfway)
let rot_50 = slerp.interpolate(0.5);

// Get rotation at t=0.75 (75% from rot1 to rot2)
let rot_75 = slerp.interpolate(0.75);

pub fn times(n: usize) -> Vec<f64>

Get times at which the interpolated rotations would have a constant angular velocity

Arguments

• n - The number of times to generate

Returns

A vector of times between 0.0 and 1.0

Examples

use scirs2_spatial::transform::{Rotation, Slerp};
use scirs2_core::ndarray::array;
use std::f64::consts::PI;

let rot1 = Rotation::identity();
let rot2 = Rotation::from_euler(&array![0.0, 0.0, PI].view(), "xyz").unwrap();
let slerp = Slerp::new(rot1, rot2).unwrap();

// Get 5 times for constant angular velocity
let times = Slerp::times(5);
// Should be [0.0, 0.25, 0.5, 0.75, 1.0]

Trait Implementations

impl Clone for Slerp

fn clone(&self) -> Slerp

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Slerp

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.