This works (SplineDegree -> 2)

ParametricPlot[BezierFunction[{{0, 0}, {1, 0.5}, {2, 2}}, SplineDegree -> 2][u], {u, 0, 1}]

BezierFunction SplineDegree 2

but this does not (SplineDegree -> 1)

ParametricPlot[BezierFunction[{{0, 0}, {1, 0.5}, {2, 2}}, SplineDegree -> 1][u], {u, 0, 1}]

BezierFunction::invdeg: Value of option SplineDegree -> 1 should be a positive integer, or a list of positive integers

I found no reference to a possible issue in the documentation for BezierFunction.

SplineDegree -> 1 works fine with BSplineFunction and BezierCurve; shouldn't it also work with BezierFunction?

(Mma 8.0.4 Mac OSX)

  • 4
    $\begingroup$ The only value that seems to work for an arbitrary list of values seems to be the length of the list minus 1. $\endgroup$
    – Heike
    Commented Jul 11, 2012 at 16:21
  • 5
    $\begingroup$ When you look at the definition of Bézier curves you can see why the degree of the polynomial has to be equal to the number of points minus one, like Heike pointed out. The error message could be more helpful here, though. $\endgroup$ Commented Jul 11, 2012 at 18:55
  • 3
    $\begingroup$ @ThiesHeidecke And yet SplineDegree->1 works for BezierCurve[]? You get straight lines when you put that in a Graphics[]. What am I missing? $\endgroup$
    – JxB
    Commented Jul 11, 2012 at 19:01
  • 3
    $\begingroup$ @ThiesHeidecke And moreover, the option SplineDegree which is explicitly mentioned in the docs for BezierFunction is then completely misleading because it suggests that the function works just like BezierCurve. So my guess is that they did mean to make these two functions work the same way, but forgot to partition the argument lis of BezierFunction according to the SplineDegree when it's explicitly given. $\endgroup$
    – Jens
    Commented Jul 11, 2012 at 19:01
  • $\begingroup$ Yes, this could definitely be improved on Wolfram's side. It is confusing as it is at the moment. $\endgroup$ Commented Jul 11, 2012 at 19:06

2 Answers 2


Reason for incompatibility

Yes, the doc shouldn't mention that it is fully compatible (that's an oversight...). BSplineFunction and BSplineCurve are fully compatible as far as I remember, but not BezierCurve and BezierFunction.

The reason is that what BezierCurve is doing when it has more than d+1 control points for SplineDegree->d case is something called composite Bezier curve. Essentially, the remainder of control points are grouped in d points, and creating degree d spline by carrying the last point from the previous curve.

pts = {{0, 0}, {1, 1}, {2, -1}, {3, 0}, {4, 2}, {6, -1}, {7, 3}, {8, -1}, {9, 1}, {10, -2}};

Graphics[{BezierCurve[pts], Green, Line[pts], Red, Point[pts]}]

composite bezier

It is a convenient hack that graphics / CAD people has been using for a long time, and it makes sense when you are creating multiple continuous curve segments.

not c1

But the problem with it for BezierFunction is that:

  1. it does not guarantee the continuous derivative at the connection points (which are marked with blue circles). It only guarantees $C^0$:

  2. Another problem is parametrization. Should parameters run between 0 to 1 (by uniformly dividing by the number of curve segments), or what... None of this is a problem for graphics primitives.

  3. This idea is not working well in multi-dimensional case (it can be extended, but no one uses it and has no mathematical meaning).

  4. There are few mathematical ways to make the connection $C^d$ when $d$ is the degree, nonetheless (introducing intermediate control points or using smoothing function), but then it is not matching with BezierCurve either.

So, we decided not to support it.

Work around

  1. SplineDegree->1 case: Just use BSplineFunction. It is exactly the same parametrization, running between 0 to 1, uniformly divided by the number of line segments.

  2. SplineDegree->d where d > 1: CompositeBezierFunction code will be provided.

  • $\begingroup$ Taken up by work. I will try to finish up the code and modify the post soon. $\endgroup$ Commented Jul 12, 2012 at 14:31
  • 2
    $\begingroup$ Couldn't BezierFunction simply act like your CompositeBezierFunction whenever a non-maximal SplineDegree is explicitly specified? $\endgroup$
    – Jens
    Commented Jul 12, 2012 at 16:08
  • $\begingroup$ @Yu-SungChang I just want to remind you that you promised to provide the CompositeBezierFunction code. $\endgroup$ Commented Jul 12, 2022 at 2:25

I've made a function like what @yu-sung-chang was suggesting.

compositeBezierPoints[bezierCurvePoints_, degree_Integer] :=
  Partition[bezierCurvePoints, UpTo[degree + 1], 1][[1 ;; -1 ;; degree]],
  Length[#] > 1 &]

compositeBezierPoints[bezierCurvePoints_, 1] :=
  Partition[bezierCurvePoints, UpTo[2], 1],
  Length[#] > 1 &]

If you input the points of the BezierCurve, and the degree (Automatic is degree 3), then compositeBezierPoints breaks up the points into a new set of points expected by BezierFunction. You would map BezierFunction over this list to get a list of functions that are each parameterized from 0 to 1. Here's a Manipulate showing the equivalence for a range of degrees:

pts = Table[{i, RandomReal[{-10, 10}]}, {i, 15}];
    Graphics[{Red, Point[pts]}], 
      Evaluate[Through[(BezierFunction /@ compositeBezier[pts, d])[t]]],
      {t, 0, 1}], 
    Graphics[{Black, Dashed, BezierCurve[pts, SplineDegree -> d]}]],
  {d, 1, 6, 1}]

You can re-parameterize the composite parts into a Piecewise function that itself runs from 0 to 1. I use BezierSymbolicFunction (found somewhere on MSE) to get the arc lengths in order to scale the segments:

BezierSymbolicFunction[pts_?MatrixQ] :=
Function[Evaluate[Sum[pts[[i+1]] BernsteinBasis[Length[pts]-1, i, #], {i, 0, Length[pts]-1}]]]

makeBezierPiecewise[bezierCurvePoints_, degree_Integer] :=
Module[{symbolicSegments, bezierSegments, lengths, ends},
  symbolicSegments = BezierSymbolicFunction /@ compositeBezier[bezierCurvePoints, degree];
  bezierSegments = BezierFunction /@ compositeBezier[bezierCurvePoints, degree];
  lengths = ArcLength[#[t], {t, 0, 1}]& /@ symbolicSegments;
  ends = Prepend[Accumulate[lengths/Total[lengths]], 0.];
          bezierSegments[[i]][(#-ends[[i]])/(ends[[i+1]] - ends[[i]])],
          ends[[i]] < # <= ends[[i+1]]},
        {i, 1, Length[ends]-1}]]]]]

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.