WOLFRAM

Wolfram Language & System Documentation Center

BezierCurve[{p1,p2,…}]

represents a Bézier curve with control points pi.

Details and Options
Details and Options Details and Options
Examples  
Basic Examples  
Scope  
Basic Uses  
Specifications  
Graphics  
Regions  
Options  
SplineDegree  
SplineClosed  
Applications  
Fonts  
Vector Graphics  
Properties & Relations  
Interactive Examples  
Neat Examples  
See Also
Related Guides
History
Cite this Page

BezierCurve

BezierCurve[{p1,p2,…}]

represents a Bézier curve with control points pi.

Details and Options

  • BezierCurve is also known as a Bézier spline or Bernstein polynomial curve.
  • BezierCurve is typically used to represent curved paths in fonts and vector graphics.
  • Control points pi are ordinary coordinates such as {x,y} or {x,y,z}.
  • BezierCurve[{p1,p2,p3,p4}] represents a simple cubic Bézier curve.
  • A BezierCurve with more than four control points will represent a composite cubic Bézier curve.
  • Composite curves can represent a wider variety of shapes using multiple Bézier segments.
  • BezierCurve can be used as a geometric region and a graphics primitive.
  • In graphics, the points pi can be Scaled, Offset, ImageScaled and Dynamic expressions.
  • Graphics rendering is affected by directives such as Thickness, Dashing, JoinForm, CapForm and color.
  • The following options can be given:
  • SplineDegree Automaticdegree of polynomial basis
    SplineClosed Falsewhether to make the surface closed
  • The option SplineDegree->d specifies that the underlying polynomial basis should have maximal degree d.
  • With SplineDegree->d, BezierCurve with d+1 control points yields a simple degree-d Bézier curve. With fewer control points, a lower-degree curve is generated. With more control points, a composite Bézier curve is generated.
  • A degree-d BezierCurve with n control points represents the region {}, where B_(k,d) is the k^(th) Bernstein basis function of degree d.

Examples

open all close all

Basic Examples  (3)

A Bézier curve and its control points in 2D:

Wolfram Language code: pts = {{0, 0}, {1, 1}, {2, -1}, {3, 0}};
Wolfram Language code: Graphics[{BezierCurve[pts], Dashed, Gray, Line[pts], Red, Point[pts]}]

A Bézier curve and its control points in 3D:

Wolfram Language code: pts = {{0, 0, 0}, {1, 1, 1}, {2, -1, 1}, {3, 0, 2}}
Wolfram Language code: Graphics3D[{BezierCurve[pts], Dashed, Gray, Line[pts], Red, Point[pts]}]

Arc length and bounds:

Wolfram Language code: reg = BezierCurve[{{0, 0}, {1, 1}, {2, -1}}];
Wolfram Language code: ArcLength[reg]
Wolfram Language code: RegionBounds[reg]

The letter "S" constructed from Bézier curves:

Wolfram Language code: Graphics[{LinearGradientFilling[{StandardRed, StandardYellow}], EdgeForm[Thick], FilledCurve[BezierCurve[IconizedObject[«[image]»]]]}]

Scope  (26)

Basic Uses  (4)

Model curves that are linear:

Wolfram Language code: Graphics[BezierCurve[{{0, 0}, {2, 1}}]]

Nonlinear:

Wolfram Language code: Graphics[BezierCurve[{{-3, 0}, {6, 5}, {-6, -5}, {3, 0}}]]

Model curves that are open:

Wolfram Language code: Graphics[BezierCurve[{{-1, 3}, {-2, 0}, {2, 0}, {1, 3}}]]

Closed:

Wolfram Language code: Graphics[BezierCurve[{{0, 1}, {-1, 0}, {1, 0}}, SplineClosed -> True]]

Model curves that are filled:

Wolfram Language code: Graphics[{FilledCurve[BezierCurve[IconizedObject[«[image]»]]]}]

Unfilled:

Wolfram Language code: Graphics[BezierCurve[IconizedObject[«[image]»]]]

Summary box:

Wolfram Language code: BezierCurve[{{-3, 0}, {6, 5}, {-6, -5}, {3, 0}}]

Specifications  (4)

A quadratic Bézier curve requires three control points:

Wolfram Language code: Graphics[BezierCurve[{{-1, 0}, {0, 2}, {1, 0}}]]
Wolfram Language code: Graphics3D[BezierCurve[{{-1, 0, 0}, {0, 2, 1}, {1, 0, 0}}]]

A cubic Bézier curve requires four control points:

Wolfram Language code: Graphics[BezierCurve[{{-3, 0}, {6, 5}, {-6, -5}, {3, 0}}]]
Wolfram Language code: Graphics3D[BezierCurve[{{-3, -1, 0}, {6, 5, 5}, {-6, -5, -5}, {3, 1, 0}}]]

In general, a simple degree-d Bézier curve requires (d+1) control points:

Wolfram Language code: pts = {{0, 0}, {(1/3), (Sqrt[3]/2)}, {(2/3), (Sqrt[3]/2)}, {1, 0}, {(4/3), (Sqrt[3]/2)}, {(5/3), (Sqrt[3]/2)}, {2, 0}};
Wolfram Language code: deg = Length[pts] - 1;
Wolfram Language code: BezierCurve[pts, SplineDegree -> deg]
Wolfram Language code: Graphics[%]

With fewer control points, a lower-degree curve is generated:

Wolfram Language code: BezierCurve[Take[pts, 4], SplineDegree -> deg]
Wolfram Language code: Graphics[%]

With more control points, a composite Bézier curve is generated:

Wolfram Language code: BezierCurve[pts, SplineDegree -> 3]
Wolfram Language code: Graphics[%]

A Bézier curve that is open:

Wolfram Language code: Graphics[{BezierCurve[{{-2, 0}, {-1, 2}, {1, 2}, {2, 0}}]}]

Closed:

Wolfram Language code: Graphics[{BezierCurve[{{-2, 0}, {-1, 2}, {1, 2}, {2, 0}}, SplineClosed -> True]}]

Graphics  (12)

Colored curves:

Wolfram Language code: Table[Graphics[{c, BezierCurve[{{0, 0}, {1, 2}, {3, 2}, {4, 0}}]}], {c, {RGBColor[0.93, 0.27, 0.27], RGBColor[0.14, 0.8, 0.14], RGBColor[0.4, 0.6, 1]}}]

Bézier curves with different thicknesses:

Wolfram Language code: Table[Graphics[{Thickness[i], BezierCurve[{{0, 0}, {1, 2}, {3, 2}, {4, 0}}]}], {i, {Tiny, Small, Medium, Large}}]
Wolfram Language code: Table[Graphics[{t, BezierCurve[{{0, 0}, {1, 2}, {3, 2}, {4, 0}}]}], {t, {Thin, Thick}}]

Thickness scaled relative to the PlotRange:

Wolfram Language code: Table[Graphics[{Thickness[i], BezierCurve[{{0, 0}, {1, 2}, {3, 2}, {4, 0}}]}], {i, {.005, .05, .1}}]

Thickness in printer's points:

Wolfram Language code: Table[Graphics[{AbsoluteThickness[i], BezierCurve[{{0, 0}, {1, 2}, {3, 2}, {4, 0}}]}], {i, {1, 5, 10}}]

Dashed curves:

Wolfram Language code: Table[Graphics[{Dashing[i], BezierCurve[{{0, 0}, {1, 2}, {3, 2}, {4, 0}}]}], {i, {Tiny, Small, Medium, Large}}]
Wolfram Language code: Table[Graphics[{d, BezierCurve[{{0, 0}, {1, 2}, {3, 2}, {4, 0}}]}], {d, {Dotted, Dashed, DotDashed}}]

Opacity determines the curve transparency:

Wolfram Language code: Table[Graphics[{Opacity[o], BezierCurve[{{0, 0}, {1, 2}, {3, 2}, {4, 0}}]}], {o, {0.1, 0.5, 0.9}}]

EdgeForm can be used to specify the curve style when used as a boundary in a FilledCurve:

Wolfram Language code: Graphics[{EdgeForm[{StandardBlue, Thick}], Opacity[0.1], FilledCurve[BezierCurve[{{0, 0}, {1, 2}, {3, 2}, {4, 0}}]]}]

BezierCurve can be used as the curve for an Arrow in 2D:

Wolfram Language code: Graphics[{Arrowheads[Large], Arrow[BezierCurve[{{0, 0}, {1, 2}, {3, 2}, {4, 0}}]]}]

3D:

Wolfram Language code: Graphics3D[{Arrowheads[Large], Arrow[BezierCurve[{{0, 0, 0}, {1, 2, 2}, {3, 2, 02}, {4, 0, 0}}]]}]

In 3D, BezierCurve can be used as the curve for a Tube:

Wolfram Language code: Graphics3D[{Tube[BezierCurve[{{0, 0, 0}, {1, 2, 2}, {3, 2, 02}, {4, 0, 0}}], 0.1]}]

Tube with Arrow:

Wolfram Language code: Graphics3D[{Arrowheads[0.2], Arrow[Tube[BezierCurve[{{0, 0, 0}, {1, 2, 2}, {3, 2, 02}, {4, 0, 0}}], 0.1]]}]

BezierCurve can be used in GraphicsComplex:

Wolfram Language code: Graphics[{GraphicsComplex[{{0, 0}, {1, 2}, {3, 2}, {4, 0}}, BezierCurve[{1, 2, 3, 4}]]}]

By default, control points are assumed to be in world coordinates:

Wolfram Language code: pts = {{0, 0}, {(1/4), 1}, {(3/4), 1}, {1, 0}};
Wolfram Language code: Table[Graphics[{BezierCurve[pts]}, Frame -> True, PlotRange -> {{0, pr}, {0, pr}}], {pr, {1, 2, 4}}]

Use Scaled to specify control points relative to the PlotRange:

Wolfram Language code: Table[Graphics[{BezierCurve[Map[Scaled, pts]]}, Frame -> True, PlotRange -> {{0, pr}, {0, pr}}], {pr, {4, 8, 16}}]

Use ImageScaled to specify control points relative to the whole image region in 2D:

Wolfram Language code: Table[Graphics[{BezierCurve[Map[ImageScaled, pts]]}, Frame -> True, PlotRange -> {{0, pr}, {0, pr}}], {pr, {4, 8, 16}}]

Use Offset to apply an absolute offset to control points in 2D:

Wolfram Language code: pts = {{0, 0}, {(1/4), 1}, {(3/4), 1}, {1, 0}};
Wolfram Language code: offsets = {{-80, 0}, {0, 0}, {80, 0}};
Wolfram Language code: Graphics[{Table[BezierCurve[Map[Offset[offset, #]&, pts]], {offset, offsets}]}, PlotRange -> {{-1.4, 2.4}, {-0.1, 1}}, ImageSize -> 250]

Control points can be Dynamic:

Wolfram Language code: DynamicModule[{z = 0, pts}, pts = {{Dynamic[{0, z}], {1, 2}, {3, 2}, {4, 0}}}; {Slider[Dynamic[z], {0, 4}], Graphics[{BezierCurve[pts]}]}]

Regions  (6)

Embedding dimension:

Wolfram Language code: reg = BezierCurve[{{Subscript[c, 1], Subscript[c, 2]}, {Subscript[c, 3], Subscript[c, 4]}, {Subscript[c, 5], Subscript[c, 6]}}];
Wolfram Language code: RegionEmbeddingDimension[reg]

Geometric dimension:

Wolfram Language code: RegionDimension[reg]

Point membership test:

Wolfram Language code: reg = BezierCurve[{{0, 0}, {1, 2}, {3, 2}, {4, 0}}];
Wolfram Language code: {RegionMember[reg, {0, 0}], RegionMember[reg, {0, 1}]}

Arc length:

Wolfram Language code: reg = BezierCurve[{{0, 0}, {1, 2}, {2, 0}}];
Wolfram Language code: {ArcLength[reg], RegionMeasure[reg]}

Centroid:

Wolfram Language code: c = RegionCentroid[reg]
Wolfram Language code: Show[Region[reg], Graphics[{LightDarkSwitched[Black, White], Point[c]}]]

Distance from a point:

Wolfram Language code: reg = BezierCurve[{{-1, -1}, {0, 1}, {1, -1}}];
Wolfram Language code: {RegionDistance[reg, {-1, -1}], RegionDistance[reg, {2, 2}]}

Visualize equidistance contours:

Wolfram Language code: Show[Region[reg], ContourPlot[Evaluate@RegionDistance[reg, {x, y}], {x, -4, 4}, {y, -4, 3}, Contours -> {1, 2, 3}, ...], Frame -> True]

Signed distance from a point:

Wolfram Language code: reg = BezierCurve[{{-1, -1}, {0, 1}, {1, -1}}];
Wolfram Language code: {SignedRegionDistance[reg, {-1, -1}], SignedRegionDistance[reg, {2, 2}]}

A Bézier curve is bounded:

Wolfram Language code: reg = BezierCurve[{{-1, -1}, {0, 1}, {1, -1}}];
Wolfram Language code: BoundedRegionQ[reg]

Calculate its bounds:

Wolfram Language code: bb = CoordinateBoundingBox[reg]
Wolfram Language code: Show[Region[reg], Graphics[{Opacity[0.1], EdgeForm[Dashed], Cuboid@@bb}]]

Options  (3)

SplineDegree  (2)

By default, a BezierCurve with 4 or more control points will use a degree of 3:

Wolfram Language code: pts = Table[{i, (-1) ^ i}, {i, 10}];
Wolfram Language code: {BezierCurve[Take[pts, 4]], BezierCurve[Take[pts, 10]]}

With fewer control points, a lower degree is used:

Wolfram Language code: {BezierCurve[Take[pts, 2]], BezierCurve[Take[pts, 3]]}

Use SplineDegree to specify that a lower degree should be used:

Wolfram Language code: BezierCurve[pts, SplineDegree -> 1]

A higher degree:

Wolfram Language code: BezierCurve[pts, SplineDegree -> 9]

For a BezierCurve with n control points, specifying a degree d where d < n-1 will give a composite Bézier curve:

Wolfram Language code: pts = Table[{i, 2(-1) ^ i}, {i, 7}];
Wolfram Language code: Region[BezierCurve[pts, SplineDegree -> #]]& /@ {2, 3, 4}

SplineClosed  (1)

By default, the curve is open:

Wolfram Language code: pts = {{0, -(1/2)}, {(Sqrt[3]/2), -(1/2)}, {(Sqrt[3]/2), (1/2)}, {0, (1/2)}, {-(Sqrt[3]/2), (1/2)}, {-(Sqrt[3]/2), -(1/2)}};
Wolfram Language code: Graphics[{BezierCurve[pts]}]

Use SplineClosed to close the curve:

Wolfram Language code: Graphics[{BezierCurve[pts, SplineClosed -> True]}]

This is equivalent to appending the first control point to the end of the array:

Wolfram Language code: Graphics[{BezierCurve[Append[pts, First[pts]]]}]

Applications  (6)

Fonts  (4)

Fonts typically use Bézier curves to define the boundaries of glyphs:

Wolfram Language code: Graphics[BezierCurve[#]]& /@ {IconizedObject[«[image]»], IconizedObject[«[image]»], IconizedObject[«[image]»]}

Specify different edge styles:

Wolfram Language code: glyph = FilledCurve[BezierCurve[IconizedObject[«[image]»]]];
Wolfram Language code: Graphics[{EdgeForm[#], FaceForm[], glyph}]& /@ {Thick, Dashed, StandardRed}

Filling styles:

Wolfram Language code: Graphics[{#, glyph}]& /@ {StandardBlue, LinearGradientFilling[{StandardRed, StandardYellow}], HatchFilling[0, 1, 3]}

Effects:

Wolfram Language code: Graphics[{#, glyph}, PlotRangePadding -> Scaled[0.05]]& /@ {DropShadowing[], Haloing[StandardYellow, 0, 5], Blurring[]}

Simulate different font weights using RegionDilation:

Wolfram Language code: glyph = FilledCurve[Map[List, BezierCurve /@ {IconizedObject[«[image]»], IconizedObject[«[image]»], IconizedObject[«[image]»]}]];
Wolfram Language code: Table[Graphics[RegionDilation[glyph, t]], {t, {0, 2}}]

Haloing:

Wolfram Language code: Table[Graphics[{Haloing[ThemeColor["Foreground"], t], glyph}, PlotRangePadding -> Scaled[.1]], {t, {0, 5}}]

Simulate different font slants with ShearingTransform:

Wolfram Language code: glyph = FilledCurve[Map[List, BezierCurve /@ {IconizedObject[«[image]»], IconizedObject[«[image]»], IconizedObject[«[image]»]}]];
Wolfram Language code: Table[Graphics[GeometricTransformation[glyph, ShearingTransform[θ , {1, 0}, {0, 1}]]], {θ, {0, 20Degree}}]

Vector Graphics  (2)

Use BezierCurve to draw shapes consisting of freeform paths:

Wolfram Language code: Graphics[{BezierCurve[IconizedObject[«[image]»]]}]

Use FilledCurve to style the shape interior:

Wolfram Language code: Graphics[{LinearGradientFilling[{Hue[0.333, 0.8250000000000001, 0.639], Hue[0.169, 1, 0.9530000000000001]}, Top], EdgeForm[Thick], FilledCurve[BezierCurve[IconizedObject[«[image]»]]]}]

Use multiple Bézier curves to draw more complex shapes:

Wolfram Language code: curves = BezierCurve /@ {IconizedObject[«[image]»], IconizedObject[«[image]»], IconizedObject[«[image]»], IconizedObject[«[image]»], IconizedObject[«[image]»]};
Wolfram Language code: Graphics[curves]

Style the curve interiors:

Wolfram Language code: Graphics[{FilledCurve[List /@ curves], RGBColor[0.9058724017188509, 0.13725482819401516, 0., 1.], FilledCurve[curves[[1]]]}]

Properties & Relations  (14)

A BezierCurve with degree 1 is equivalent to Line:

Wolfram Language code: pts = {{0, -1}, {2, 1}, {4, -1}, {6, 1}};
Wolfram Language code: Graphics /@ {BezierCurve[pts, SplineDegree -> 1], Line[pts]}

A BezierCurve is a special case of BSplineCurve:

Wolfram Language code: pts = {{-3, 0}, {6, 5}, {-6, -5}, {3, 0}};
Wolfram Language code: Graphics /@ {BezierCurve[pts], BSplineCurve[pts]}

Use RegionConvert to get the equivalent BSplineCurve:

Wolfram Language code: RegionConvert[BezierCurve[pts], "Spline"]

BezierSurface is a higher-dimensional form of BezierCurve that takes a rectangular array of control points:

Wolfram Language code: pts = (⁠| | | | | | ---------- | ----------- | ----------- | ----------- | | {0, 0, 7} | {0, 3, 10} | {0, 7, 10} | {0, 10, 7} | | {3, 0, 10} | {3, 3, 14} | {3, 7, 14} | {3, 10, 10} | | {7, 0, 10} | {7, 3, 14} | {7, 7, 14} | {7, 10, 10} | | {10, 0, 7} | {10, 3, 10} | {10, 7, 10} | {10, 10, 7} |⁠);
Wolfram Language code: Graphics3D[BezierSurface[pts]]

The boundary edges of a BezierSurface are formed from four Bézier curves:

Wolfram Language code: bc = Map[BezierCurve, {pts[[1]], pts[[-1]], pts[[All, 1]], pts[[All, -1]]}];
Wolfram Language code: Graphics3D[{BezierSurface[pts], Thick, StandardRed, bc}]

All isoparametric curves on a BezierSurface are valid Bézier curves:

Wolfram Language code: uc = Table[BezierCurve[Map[#[u]&, Map[BezierFunction, pts]]], {u, 0, 1, 1 / 5}]; vc = Table[BezierCurve[Map[#[v]&, Map[BezierFunction, Transpose[pts]]]], {v, 0, 1, 1 / 5}];
Wolfram Language code: Graphics3D[{BezierSurface[pts], Thick, RGBColor[0.14, 0.8, 0.14], uc, RGBColor[0.4, 0.6, 1], vc}]

A Circle can be closely approximated with a composite BezierCurve:

Wolfram Language code: Region /@ {BezierCurve[IconizedObject[«[image]»]], Circle[]}

The approximation error is minor:

Wolfram Language code: RegionHausdorffDistance@@%

BezierCurve always interpolates its first and last control point:

Wolfram Language code: pts = {{0, -1}, {1, 2}, {2, -2}, {3, 1}};
Wolfram Language code: Graphics[{BezierCurve[pts], Red, Point[{First[pts], Last[pts]}]}]

A Bézier curve lies in the convex hull of its control points:

Wolfram Language code: pts = {{0, -1}, {2, 1}, {4, -1}, {6, 1}, {4, 2}};
Wolfram Language code: hull = ConvexHullMesh[pts, MeshCellStyle -> {0 -> Red, 2 -> Opacity[1 / 4]}];
Wolfram Language code: Show[hull, Region[BezierCurve[pts, SplineDegree -> 4]]]

In 3D, a Bézier curve with coplanar control points lies in the same plane as its points:

Wolfram Language code: pts = {{-3, -1, 0}, {6, 10, 0}, {-6, -10, 0}, {3, 1, 0}};
Wolfram Language code: pts//CoplanarPoints
Wolfram Language code: Graphics3D[{InfinitePlane[Take[pts, 3]], BezierCurve[pts]}, Lighting -> "Accent", ViewPoint -> #]& /@ {2{1, -1, 1}, Front, Top}

BezierFunction gives the position on a BezierCurve corresponding to a specific parameter value:

Wolfram Language code: pts = {{-3, 0}, {6, 5}, {-6, -5}, {3, 0}};
Wolfram Language code: bfunc = BezierFunction[pts]
Wolfram Language code: positions = Table[bfunc[u], {u, 0, 1, 1 / 10}];
Wolfram Language code: Graphics[{BezierCurve[pts], StandardRed, PointSize[0.02], Point[positions]}]

A Bézier curve can be constructed using Bernstein polynomials to take a weighted sum of its control points:

Wolfram Language code: pts = {{0, -1}, {1, 1}, {2, -1}, {3, 1}};
Wolfram Language code: bezier[t_] := Sum[BernsteinBasis[3, i, t] * pts[[i + 1]], {i, 0, 3}]
Wolfram Language code: GraphicsRow[{ParametricPlot[bezier[t], {t, 0, 1}, Frame -> True, Axes -> False], Graphics[BezierCurve[pts], Frame -> True]}, ImageSize -> 400]

Use BernsteinBasis to visualize the weight of each control point along the curve:

Wolfram Language code: weights = Table[BernsteinBasis[3, i, t], {i, 0, 3}];
Wolfram Language code: Plot[weights, {t, 0, 1}, PlotLegends -> {"SubscriptBox[p, 1]", "SubscriptBox[p, 2]", "SubscriptBox[p, 3]", "SubscriptBox[p, 4]"}]

A Bézier curve is affine invariant:

Wolfram Language code: pts = {{0, -1}, {2, 2}, {4, -2}, {6, 1}};
Wolfram Language code: A = AffineTransform[{{{1, 1}, {0, 2}}, {1, 2}}];
Wolfram Language code: {Graphics[GeometricTransformation[BezierCurve[pts], A], Frame -> True], Graphics[BezierCurve[A[pts]], Frame -> True]}

Averaging the control points of two Bézier curves is equivalent to averaging the curves themselves:

Wolfram Language code: pts1 = {{0, -1}, {2, 1}, {4, 2}, {6, 2}}; pts2 = {{2, -1}, {3, 1}, {4, -1}, {6, 0}};
Wolfram Language code: Graphics[{Thick, RGBColor[0.4, 0.6, 1], BezierCurve[pts1], RGBColor[0.98, 0.56, 0.17], BezierCurve[pts2], RGBColor[0.93, 0.27, 0.27], BezierCurve[Mean[{pts1, pts2}]]}, Frame -> True]
Wolfram Language code: ParametricPlot[{BezierFunction[pts1][t], BezierFunction[pts2][t], Mean[{BezierFunction[pts1][t], BezierFunction[pts2][t]}]}, {t, 0, 1}, Frame -> True, Axes -> False, PlotStyle -> {RGBColor[0.4, 0.6, 1], RGBColor[0.98, 0.56, 0.17], RGBColor[0.93, 0.27, 0.27]}]

A composite Bézier curve may not be smooth at the point where two segments meet:

Wolfram Language code: pts = {{0, 0}, {1, -1}, {3, -1}, {3, 0}, {4, 1}, {5, 1}, {6, 0}};
Wolfram Language code: Graphics[{BezierCurve[pts], Dashed, Gray, Line[pts], Red, Point[pts]}]

Set points adjacent to the boundary to be collinear to guarantee composite Bézier curve:

Wolfram Language code: pts[[5, 1]] = 3;
Wolfram Language code: Graphics[{BezierCurve[pts], Dashed, Gray, Line[pts], Red, Point[pts]}]

A Bézier curve can be elevated to an equivalent curve of any higher degree:

Wolfram Language code: pts = {{0, 0}, {2, 3}, {4, 0}};
Wolfram Language code: elevate[pts_] := With[...]
Wolfram Language code: epts = Table[Nest[elevate, pts, d], {d, 0, 3}];
Wolfram Language code: Graphics /@ Table[{BezierCurve[epts[[i]], SplineDegree -> i + 2], Dashed, Gray, Line[epts[[i]]], Red, Point[epts[[i]]]}, {i, Length[epts]}]

SubdivisionRegion generates smooth surfaces from control meshes instead of control points:

Wolfram Language code: Region /@ {SubdivisionRegion[[image]], BezierCurve[IconizedObject[«[image]»]]}

Interactive Examples  (2)

A simple Bézier curve editor:

Wolfram Language code: Column[{Manipulate[DynamicModule[{}, $curve = BezierCurve[pts, SplineDegree -> d, SplineClosed -> c]; Graphics[{$curve, Dashed, Opacity[0.5], Line[pts]}, PlotRange -> 5, Frame -> True, ImageSize -> 250]], {{pts, {{-4, -4}, {-3, 4}, {3, -4}, {4, 4}}}, Locator, LocatorAutoCreate -> True}, {{d, 3, "degree"}, 2, 6, 1}, {{c, False, "closed"}, {False, True}}], Button["Copy Curve to Clipboard", CopyToClipboard[$curve]]}]

Smoothly interpolate between two simple Bézier curves:

Wolfram Language code: interpolateCurves[pts1_, pts2_] := Manipulate[Graphics[{BezierCurve[pts1(1 - t) + pts2 t], Opacity[0.25], Dashed, BezierCurve[pts1], BezierCurve[pts2]}], {t, 0, 1}]
Wolfram Language code: interpolateCurves[{...}, {...}]

Two composite curves:

Wolfram Language code: interpolateCurves@@{{...}, {...}}

Neat Examples  (1)

A flower constructed from a composite Bézier curve:

Wolfram Language code: Graphics[BezierCurve[Table[{Cos[2k Pi / 13], Sin[2 k Pi / 13]}, {k, 0, 156, 4}]]]
Wolfram Research (2008), BezierCurve, Wolfram Language function, https://reference.wolfram.com/language/ref/BezierCurve.html.

Text

Wolfram Research (2008), BezierCurve, Wolfram Language function, https://reference.wolfram.com/language/ref/BezierCurve.html.

CMS

Wolfram Language. 2008. "BezierCurve." Wolfram Language & System Documentation Center. Wolfram Research. https://reference.wolfram.com/language/ref/BezierCurve.html.

APA

Wolfram Language. (2008). BezierCurve. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/BezierCurve.html

BibTeX

@misc{reference.wolfram_2026_beziercurve, author="Wolfram Research", title="{BezierCurve}", year="2008", howpublished="\url{https://reference.wolfram.com/language/ref/BezierCurve.html}", note=[Accessed: 13-June-2026]}

BibLaTeX

@online{reference.wolfram_2026_beziercurve, organization={Wolfram Research}, title={BezierCurve}, year={2008}, url={https://reference.wolfram.com/language/ref/BezierCurve.html}, note=[Accessed: 13-June-2026]}