Struct Point

pub struct Point<T> {

    pub x: T,
    pub y: T,
    pub z: T,
    pub xp: T,
    pub yp: T,
    pub zp: T,
    pub xpp: T,
    pub ypp: T,
    pub zpp: T,
    pub xppp: T,
    pub yppp: T,
    pub zppp: T,
    pub optimizer_can_adjust_pos: bool,
}

A point in 3D space with 1st, 2nd, and 3rd derivatives also specified

Fields

x: T

y: T

z: T

xp: T

yp: T

zp: T

xpp: T

ypp: T

zpp: T

xppp: T

yppp: T

zppp: T

optimizer_can_adjust_pos: bool

Implementations

impl<T> Point<T>

where T: MyFloat,

pub fn new(x: T, y: T, z: T) -> Self

pub fn set_at_i(&mut self, i: usize, value: T)

pub fn get_at_i(&self, i: usize) -> T

pub fn descend_derivatives(&mut self, v: &[Option<T>], lr: T)

Descends derivatives specified in v
Used by the optimizer to adjust the parameters of each point Format is xp, xpp, xppp, yp, ypp, ypp, …

This function is part of an optimization process, adjusting points to minimize a cost function improving curve smoothness.
lr parameter controls how large the adjustments are, ensuring the changes are gradual to avoid instability
v takes in &[Option<T>] to allow for no adjustment.

pub fn nudged(&self, amount: T) -> Vec<Self>

Returns all 9 possible ways to tweak the point without adjusting its position

Trait Implementations

impl<T: Clone> Clone for Point<T>

fn clone(&self) -> Point<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Point<T>

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

Formats the value using the given formatter.

impl<T> Default for Point<T>

where T: Default,

fn default() -> Self

Create a Point with all fields initialized to their default values.

impl From<PersistPoint> for Point<f64>

fn from(p: PersistPoint) -> Self

Converts to this type from the input type.

impl<T: PartialEq> PartialEq for Point<T>

fn eq(&self, other: &Point<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> StructuralPartialEq for Point<T>