Struct bezier_nd::curve::Bezier

pub struct Bezier<F, V, const D: usize> where
    F: Float,
    V: Vector<F, D>,  { /* fields omitted */ }

Implementations

impl<F, V, const D: usize> Bezier<F, V, D> where
    F: Float,
    V: Vector<F, D>, 

pub fn borrow_pt(&self, index: usize) -> &V

Get the start or end point of the Bezier - index 0 gives the start point, index 1 the end point

pub fn endpoints(self) -> (V, V)

Deconstruct and get the endpoints

pub fn get_distance(&self) -> F

Get the distance between the start and end points

pub fn line(p0: &V, p1: &V) -> Self

Create a new Bezier that is a line between two points

pub fn quadratic(p0: &V, c: &V, p1: &V) -> Self

Create a new Quadratic Bezier that is a line between two points with one absolute control points

pub fn cubic(p0: &V, c0: &V, c1: &V, p1: &V) -> Self

Create a new Cubic Bezier that is a line between two points with two absolute control points

pub fn is_line(&self) -> bool

Returns true if the Bezier is a straight line

pub fn is_quadratic(&self) -> bool

Returns true if the Bezier is a quadratic

pub fn is_cubic(&self) -> bool

Returns true if the Bezier is a cubic

pub fn scale(&mut self, s: F)

Consume the Bezier and return a new Bezier scaled separately in X and Y by two scaling parameters

pub fn map_pts<Map: Fn(V) -> V>(&mut self, map: Map)

Apply a function to all of the points in the Bezier

pub fn vector_of(&self, sc: &[F], reduce: F) -> V

Returns a vector of a combination of the vectors of the bezier

pub fn point_at(&self, t: F) -> V

Returns the point at parameter ‘t’ along the Bezier

pub fn tangent_at(&self, t: F) -> V

Returns the tangent vector at parameter ‘t’ along the Bezier

This is not necessarily a unit vector

pub fn bisect(&self) -> (Self, Self)

Returns two Bezier’s that split the curve at parameter t=0.5

For quadratics the midpoint is 1/4(p0 + 2*c + p1)

pub fn bezier_between(&self, t0: F, t1: F) -> Self

Returns the Bezier between two parameters 0 <= t0 < t1 <= 1

pub fn as_lines(&self, straightness: F) -> BezierLineIter<F, V, D>

Iterate over line segments that are ‘straight’ enough

pub fn as_points(&self, straightness: F) -> BezierPointIter<F, V, D>

Iterate over points that make ‘straight’ enough lines

pub fn is_straight(&self, straightness: F) -> bool

Returns true if the Bezier is straighter than a ‘straightness’ measure

A linear bezier is always straight.

A straightness measure for a quadratic bezier (one control point) can be thought of as the ratio between the area of the triangle formed by the two endpoints and the control point (three points must form a triangle on a plane) in relation to the distance between the endpoints (the curve will be entirely within the triangle.

A straightness measure for a cubic bezier (two control points) can be though of similarly, except that the curve now must fit within a volume given by the two control points and the endpoints; hence the straightness is measured in some way by the volume in relation to the distance between the endpoints, but also should be no straighter than the area of any one control point in relation to the disnance between the endpoints (the Bezier may be a planar curve that is quite unstraight but with a volume of zero).

Hence the straightness here is defined as the sum of (the ratio between (the distance of each control point from the straight line between the two endpoints) and (the distance between the two endpoints))

straightness is thus independent of the length of the Bezier

pub fn length(&self, straightness: F) -> F

Calculates the length given a straightness

straightness is independent of the length of the Bezier

pub fn t_of_distance(&self, straightness: F, distance: F) -> (F, bool)

pub fn arc(
    angle: F,
    radius: F,
    center: &V,
    unit: &V,
    normal: &V,
    rotate: F
) -> Self

Create a Cubic Bezier that approximates closely a circular arc

The arc has a center C, a radius R, and is of an angle (should be <= PI/2).

The arc sweeps through points a distance R from C, in a circle using a pair of the planar unit vectors in the vector space for the points.

The arc will be between an angle A1 and A2, where A2-A1 == angle, and A1==rotate

pub fn of_round_corner(corner: &V, v0: &V, v1: &V, radius: F) -> Self

Create a Cubic Bezier that is a circular arc focused on the corner point, with v0 and v1 are vectors IN to the point (P)

As it is a circular arc we have a kite P, P+k.v0, C, P+k.v1, where

|P+k.v0 - C| = |P+k.v1 - C| = r; |P-C| = d (i.e. side lengths are r, r, k, k)

with two corners being right-angles. (and d is the length of the kite diagonal opposite these right-angles).

The kite is formed from two d, r, k right-angled triangles; it has two other angles, alpha and 2theta, (alpha = angle between v0 and v1). Hence alpha = 180 - 2theta, theta = 90-(alpha/2)

Hence d^2 = r^2 + k^2; r/d = cos(theta), k/d=sin(theta)

We know cos(alpha) = v0.v1 (assuming unit vectors).

cos(alpha) = cos(180-2theta) = -cos(2theta) = -(2cos^2(theta) - 1) = 1 - 2cos^2(theta)

cos^2(theta) = (1 - cos(alpha)) / 2 = r^2/d^2

sin^2(theta) = (1 + cos(alpha)) / 2

=> d^2 = 2*r^2 / (1 - cos(alpha))

Hence also k^2, and hence d and k.

Then we require an arc given the angle of the arc is 2*theta, which requires a lambda of 4/3 * r * (1/sin(theta)-1) = 4/3 * r * (d/k - 1)

Note though that d^2/k^2 = 1/sin^2(theta) = 2/(1+cos(alpha))

hence d/k = sqrt(2/(1+cos(alpha)))

hence lambda = 4/3 * r * (sqrt(2/(1+cos(alpha))) - 1)

Trait Implementations

impl<F: Clone, V: Clone, const D: usize> Clone for Bezier<F, V, D> where
    F: Float,
    V: Vector<F, D>, 

fn clone(&self) -> Bezier<F, V, D>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F: Debug, V: Debug, const D: usize> Debug for Bezier<F, V, D> where
    F: Float,
    V: Vector<F, D>, 

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

Formats the value using the given formatter.

impl<F, V, const D: usize> Display for Bezier<F, V, D> where
    F: Float,
    V: Vector<F, D>, 

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

Display the `Bezier’ as sets of points

impl<F: PartialEq, V: PartialEq, const D: usize> PartialEq<Bezier<F, V, D>> for Bezier<F, V, D> where
    F: Float,
    V: Vector<F, D>, 

fn eq(&self, other: &Bezier<F, V, D>) -> bool

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

fn ne(&self, other: &Bezier<F, V, D>) -> bool

This method tests for !=.

impl<F: Copy, V: Copy, const D: usize> Copy for Bezier<F, V, D> where
    F: Float,
    V: Vector<F, D>, 

impl<F, V, const D: usize> StructuralPartialEq for Bezier<F, V, D> where
    F: Float,
    V: Vector<F, D>,