Struct rerun::external::eframe::egui::epaint::CubicBezierShape

pub struct CubicBezierShape {
    pub points: [Pos2; 4],
    pub closed: bool,
    pub fill: Color32,
    pub stroke: PathStroke,
}

A cubic Bézier Curve.

See also QuadraticBezierShape.

Fields

points: [Pos2; 4]

The first point is the starting point and the last one is the ending point of the curve. The middle points are the control points.

closed: bool

fill: Color32

stroke: PathStroke

Implementations

impl CubicBezierShape

pub fn from_points_stroke( points: [Pos2; 4], closed: bool, fill: Color32, stroke: impl Into<PathStroke>, ) -> CubicBezierShape

Creates a cubic Bézier curve based on 4 points and stroke.

The first point is the starting point and the last one is the ending point of the curve. The middle points are the control points.

pub fn transform(&self, transform: &RectTransform) -> CubicBezierShape

Transform the curve with the given transform.

pub fn to_path_shapes( &self, tolerance: Option<f32>, epsilon: Option<f32>, ) -> Vec<PathShape>

Convert the cubic Bézier curve to one or two PathShape’s. When the curve is closed and it has to intersect with the base line, it will be converted into two shapes. Otherwise, it will be converted into one shape. The tolerance will be used to control the max distance between the curve and the base line. The epsilon is used when comparing two floats.

pub fn visual_bounding_rect(&self) -> Rect

The visual bounding rectangle (includes stroke width)

pub fn logical_bounding_rect(&self) -> Rect

Logical bounding rectangle (ignoring stroke width)

pub fn split_range(&self, t_range: Range<f32>) -> CubicBezierShape

split the original cubic curve into a new one within a range.

pub fn num_quadratics(&self, tolerance: f32) -> u32

pub fn find_cross_t(&self, epsilon: f32) -> Option<f32>

Find out the t value for the point where the curve is intersected with the base line. The base line is the line from P0 to P3. If the curve only has two intersection points with the base line, they should be 0.0 and 1.0. In this case, the “fill” will be simple since the curve is a convex line. If the curve has more than two intersection points with the base line, the “fill” will be a problem. We need to find out where is the 3rd t value (0<t<1) And the original cubic curve will be split into two curves (0.0..t and t..1.0). B(t) = (1-t)^3P0 + 3t*(1-t)^2P1 + 3t^2*(1-t)P2 + t^3P3 or B(t) = (P3 - 3P2 + 3P1 - P0)t^3 + (3P2 - 6P1 + 3P0)t^2 + (3P1 - 3*P0)*t + P0 this B(t) should be on the line between P0 and P3. Therefore: (B.x - P0.x)/(P3.x - P0.x) = (B.y - P0.y)/(P3.y - P0.y), or: B.x * (P3.y - P0.y) - B.y * (P3.x - P0.x) + P0.x * (P0.y - P3.y) + P0.y * (P3.x - P0.x) = 0 B.x = (P3.x - 3 * P2.x + 3 * P1.x - P0.x) * t^3 + (3 * P2.x - 6 * P1.x + 3 * P0.x) * t^2 + (3 * P1.x - 3 * P0.x) * t + P0.x B.y = (P3.y - 3 * P2.y + 3 * P1.y - P0.y) * t^3 + (3 * P2.y - 6 * P1.y + 3 * P0.y) * t^2 + (3 * P1.y - 3 * P0.y) * t + P0.y Combine the above three equations and iliminate B.x and B.y, we get:

t^3 * ( (P3.x - 3*P2.x + 3*P1.x - P0.x) * (P3.y - P0.y) - (P3.y - 3*P2.y + 3*P1.y - P0.y) * (P3.x - P0.x))
+ t^2 * ( (3 * P2.x - 6 * P1.x + 3 * P0.x) * (P3.y - P0.y) - (3 * P2.y - 6 * P1.y + 3 * P0.y) * (P3.x - P0.x))
+ t^1 * ( (3 * P1.x - 3 * P0.x) * (P3.y - P0.y) - (3 * P1.y - 3 * P0.y) * (P3.x - P0.x))
+ (P0.x * (P3.y - P0.y) - P0.y * (P3.x - P0.x)) + P0.x * (P0.y - P3.y) + P0.y * (P3.x - P0.x)
= 0

or a * t^3 + b * t^2 + c * t + d = 0

let x = t - b / (3 * a), then we have:

x^3 + p * x + q = 0, where:
p = (3.0 * a * c - b^2) / (3.0 * a^2)
q = (2.0 * b^3 - 9.0 * a * b * c + 27.0 * a^2 * d) / (27.0 * a^3)

when p > 0, there will be one real root, two complex roots when p = 0, there will be two real roots, when p=q=0, there will be three real roots but all 0. when p < 0, there will be three unique real roots. this is what we need. (x1, x2, x3) t = x + b / (3 * a), then we have: t1, t2, t3. the one between 0.0 and 1.0 is what we need. <https://baike.baidu.com/item/%E4%B8%80%E5%85%83%E4%B8%89%E6%AC%A1%E6%96%B9%E7%A8%8B/8388473 />

pub fn sample(&self, t: f32) -> Pos2

Calculate the point (x,y) at t based on the cubic Bézier curve equation. t is in [0.0,1.0] Bézier Curve

pub fn flatten(&self, tolerance: Option<f32>) -> Vec<Pos2>

find a set of points that approximate the cubic Bézier curve. the number of points is determined by the tolerance. the points may not be evenly distributed in the range [0.0,1.0] (t value)

pub fn flatten_closed( &self, tolerance: Option<f32>, epsilon: Option<f32>, ) -> Vec<Vec<Pos2>>

find a set of points that approximate the cubic Bézier curve. the number of points is determined by the tolerance. the points may not be evenly distributed in the range [0.0,1.0] (t value) this api will check whether the curve will cross the base line or not when closed = true. The result will be a vec of vec of Pos2. it will store two closed aren in different vec. The epsilon is used to compare a float value.

pub fn for_each_flattened_with_t<F>(&self, tolerance: f32, callback: &mut F)

where F: FnMut(Pos2, f32),

Iterates through the curve invoking a callback at each point.

Trait Implementations

impl Clone for CubicBezierShape

fn clone(&self) -> CubicBezierShape

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CubicBezierShape

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CubicBezierShape

fn deserialize<__D>( __deserializer: __D, ) -> Result<CubicBezierShape, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<CubicBezierShape> for Shape

fn from(shape: CubicBezierShape) -> Shape

Converts to this type from the input type.

impl PartialEq for CubicBezierShape

fn eq(&self, other: &CubicBezierShape) -> 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 Serialize for CubicBezierShape

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for CubicBezierShape