Enum bezier_rs::TValue

pub enum TValue {
    Parametric(f64),
    Euclidean(f64),
    EuclideanWithinError {
        t: f64,
        error: f64,
    },
}

A structure which can be used to reference a particular point along a Bezier. Assuming a 2-dimensional Bezier is represented as a parametric curve defined by components (x(f(t), y(f(t)))), this structure defines variants for f(t).

• The Parametric variant represents the point calculated using the parametric equation of the curve at argument t. That is, f(t) = t. Speed along the curve’s parametric form is not constant. t must lie in the range [0, 1].
• The Euclidean variant represents the point calculated at a distance ratio t along the arc length of the curve in the range [0, 1]. Speed is constant along the curve’s arc length.
  • E.g. If d is the distance from the start point of a Bezier to a certain point along the curve, and l is the total arc length of the curve, that certain point lies at a distance ratio t = d / l.
  • All Bezier functions will implicitly convert a Euclidean TValue argument to a parametric t-value using binary search, computed within a particular error. That is, a point at distance ratio t*, satisfying |t* - t| <= error. The default error is 0.001. Given this requires a lengthier calculation, it is not recommended to use the Euclidean or EuclideanWithinError variants frequently in computationally intensive tasks.
• The EuclideanWithinError variant functions exactly as the Euclidean variant, but allows the error to be customized when computing t internally.

Variants

Parametric(f64)

Euclidean(f64)

EuclideanWithinError

Fields

t: f64

error: f64

Trait Implementations

impl Clone for TValue

fn clone(&self) -> TValue

Returns a copy of the value.

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

Performs copy-assignment from source.

impl PartialEq for TValue

fn eq(&self, other: &TValue) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Copy for TValue

impl StructuralPartialEq for TValue