SourceClass CubicBezierShape
from egui import CubicBezierShapeclass CubicBezierShape:A cubic Bézier Curve.
See also QuadraticBezierShape.
Properties§
@property
def closed(self, /) -> bool§
@closed.setter
def closed(self, /, closed: bool) -> None§
@property
def fill(self, /) -> Color32§
@fill.setter
def fill(self, /, fill: Color32) -> None§
@property
def stroke(self, /) -> PathStroke§
@stroke.setter
def stroke(self, /, stroke: Any) -> None§
Methods§
Sourcedef find_cross_t(self, /, epsilon: float) -> float |None§
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 - 3P0)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:
or a * t^3 + b * t^2 + c * t + d = 0
let x = t - b / (3 * a), then we have:
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 />
Sourcedef flatten(self, /, tolerance: float |None) -> list[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)
Sourcedef flatten_closed(self, /, tolerance: float |None, epsilon: float |None) -> list[list[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.
Sourcedef for_each_flattened_with_t(self, /, tolerance: float) -> list[tuple[Pos2, float]]§
Iterates through the curve invoking a callback at each point.
Source@staticmethod
def from_points_stroke(points: Sequence[Pos2], closed: bool, fill: Color32, stroke: Any) -> 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.
Sourcedef logical_bounding_rect(self, /) -> Rect§
Logical bounding rectangle (ignoring stroke width)
Sourcedef num_quadratics(self, /, tolerance: float) -> int§
def points(self, /) -> list[Pos2]§
Sourcedef sample(self, /, t: float) -> 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
def set_points(self, /, points: Sequence[Pos2]) -> None§
Sourcedef split_range(self, /, start: float, end: float) -> CubicBezierShape§
split the original cubic curve into a new one within a range.
Sourcedef to_path_shapes(self, /, tolerance: float |None, epsilon: float |None) -> list[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.
Sourcedef transform(self, /, transform: RectTransform) -> CubicBezierShape§
Transform the curve with the given transform.
Sourcedef visual_bounding_rect(self, /) -> Rect§
The visual bounding rectangle (includes stroke width)