# Struct epaint::bezier::CubicBezierShape

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

## Expand description

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§

source§### impl CubicBezierShape

### impl CubicBezierShape

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

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

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.

source#### pub fn transform(&self, transform: &RectTransform) -> Self

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

Transform the curve with the given transform.

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

#### 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.

source#### pub fn visual_bounding_rect(&self) -> Rect

#### pub fn visual_bounding_rect(&self) -> Rect

The visual bounding rectangle (includes stroke width)

source#### pub fn logical_bounding_rect(&self) -> Rect

#### pub fn logical_bounding_rect(&self) -> Rect

Logical bounding rectangle (ignoring stroke width)

source#### pub fn split_range(&self, t_range: Range<f32>) -> Self

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

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

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

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

#### 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)^3*P0 + 3*t*(1-t)^2*P1 + 3*t^2*(1-t)*P2 + t^3*P3
or B(t) = (P3 - 3*P2 + 3*P1 - P0)*t^3 + (3*P2 - 6*P1 + 3*P0)*t^2 + (3*P1 - 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 - 3P2.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 /`

>

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

#### 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

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

#### 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)

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

#### 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.

## Trait Implementations§

source§### impl Clone for CubicBezierShape

### impl Clone for CubicBezierShape

source§#### fn clone(&self) -> CubicBezierShape

#### fn clone(&self) -> CubicBezierShape

1.0.0 · source§#### fn clone_from(&mut self, source: &Self)

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

`source`

. Read moresource§### impl Debug for CubicBezierShape

### impl Debug for CubicBezierShape

source§### impl From<CubicBezierShape> for Shape

### impl From<CubicBezierShape> for Shape

source§#### fn from(shape: CubicBezierShape) -> Self

#### fn from(shape: CubicBezierShape) -> Self

source§### impl PartialEq for CubicBezierShape

### impl PartialEq for CubicBezierShape

source§#### fn eq(&self, other: &CubicBezierShape) -> bool

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

`self`

and `other`

values to be equal, and is used
by `==`

.