A renderer needs a short polyline; a CAD editor needs reliable bounds and intersections. Both can exploit the same geometry. Derivatives locate candidates, the convex hull bounds the space a curve can occupy, and subdivision tightens those bounds without changing the path. The useful distinction is between operations that preserve the curve exactly and algorithms that approximate it with a stated error.
Degree Elevation and Quadratic-to-Cubic Conversion
Any degree-\(n\) curve can be represented exactly at degree \(n+1\). The elevated controls are
\[ \mathbf P'_0=\mathbf P_0,\qquad \mathbf P'_i=\frac{i}{n+1}\mathbf P_{i-1}+\left(1-\frac{i}{n+1}\right)\mathbf P_i, \qquad \mathbf P'_{n+1}=\mathbf P_n. \]
For an SVG quadratic command with start \(\mathbf Q_0\), control \(\mathbf Q_1\), and end \(\mathbf Q_2\), the equivalent cubic controls are
\[ \mathbf C_0=\mathbf Q_0,\quad \mathbf C_1=\mathbf Q_0+\frac23(\mathbf Q_1-\mathbf Q_0),\quad \mathbf C_2=\mathbf Q_2+\frac23(\mathbf Q_1-\mathbf Q_2),\quad \mathbf C_3=\mathbf Q_2. \]
function quadraticToCubic(q0, q1, q2) {
return [
q0,
add(q0, scale(sub(q1, q0), 2 / 3)),
add(q2, scale(sub(q1, q2), 2 / 3)),
q2
];
} Degree reduction is different: a generic cubic cannot be represented exactly as a quadratic. Reduction is an approximation problem, so its result is meaningless until an error measure and any endpoint or tangent constraints are specified. For a degree-\(n\) curve with controls \(\mathbf P_i\), one useful degree-\(m\) approximation minimizes the parameter-space squared error
\[ E=\int_0^1\left\| \sum_{i=0}^{n}b_{i,n}(t)\mathbf P_i- \sum_{j=0}^{m}b_{j,m}(t)\mathbf Q_j \right\|^2\,dt. \]
Differentiating with respect to each unknown \(\mathbf Q_k\) gives the linear system
\[ \sum_{j=0}^{m}G_{kj}\mathbf Q_j= \sum_{i=0}^{n}H_{ki}\mathbf P_i, \qquad G_{kj}=I(m,k,m,j),\quad H_{ki}=I(m,k,n,i), \]
where products of Bernstein basis functions integrate exactly:
\[ I(a,r,b,s)=\int_0^1 b_{r,a}(t)b_{s,b}(t)\,dt =\frac{\binom{a}{r}\binom{b}{s}} {(a+b+1)\binom{a+b}{r+s}}. \]
Endpoint interpolation is imposed by fixing \(\mathbf Q_0=\mathbf P_0\) and \(\mathbf Q_m=\mathbf P_n\), moving their known contributions to the right-hand side, and solving only for the interior controls. A stable linear solver should operate on these small matrices directly; explicit factorial products overflow quickly, while a recurrence specialized to one matrix size is harder to verify. This least-squares projection minimizes error at equal parameter values. It does not minimize Hausdorff distance or compensate for a different parameterization, so geometric reduction may additionally reparameterize, split, and test the result against a spatial tolerance.
const quadratic = cubic.reduce(2);
const unconstrained = cubic.reduce(2, { preserveEndpoints: false }); reduce uses the integral above and preserves both endpoints by default. Setting preserveEndpoints to false computes the unconstrained projection, which can lower the integrated error while moving the ends. Neither mode silently claims a geometric minimax result.
Font Outlines
Font outlines are a concrete reason to distinguish quadratic and cubic segments. Traditional TrueType glyf outlines use straight segments and quadratic Bézier curves. A stored off-curve point is a quadratic control; two consecutive off-curve points imply an on-curve point at their midpoint, which keeps many contours compact. OpenType is a container rather than a single curve format: outlines in glyf remain quadratic, while CFF and CFF2 outlines use cubic Bézier curves.
Rendering and editing need no special curve mathematics beyond the operations already developed. Apply the font and layout transformations to the controls by affine invariance, split contours with de Casteljau when local processing is needed, and convert a quadratic segment to a cubic exactly with the controls above when a cubic-only path system is the destination. Conversion in the opposite direction is generally approximate.
Extrema and Bounding Boxes
The control-point box is cheap and always contains the curve, but it is generally loose. A tight axis-aligned box must include endpoints and every interior parameter where an axis derivative vanishes:
\[ x'(t)=0\quad\text{or}\quad y'(t)=0,\qquad 0<t<1. \]
A cubic's derivatives are quadratic, so their roots follow from the quadratic formula. Evaluate the original curve at all accepted roots and take coordinate-wise minima and maxima. The pale rectangle below bounds the control polygon; the red rectangle is the exact axis-aligned curve box.
Bounding boxes are rejection tests, not proof of intersection. Nonoverlapping boxes prove that two pieces cannot intersect; overlapping boxes say only that further work is required. For a tighter oriented box, translate the first endpoint to the origin, rotate the endpoint chord onto the x-axis, compute a box there, and transform its corners back.
Adaptive Flattening and Flatness
Displays and many fabrication formats ultimately consume line segments. Uniformly stepping through \(t\) is easy but wasteful on straight regions and insufficient in sharply curved regions. Adaptive flattening instead asks whether a segment is flat enough; if not, it splits and tests both halves.
A safe flatness bound is the largest control-point distance to the finite chord segment. For endpoints \(\mathbf A,\mathbf B\), project each control onto the chord and clamp the projection to the interval between the endpoints. If the endpoints coincide, measure distance to that single point.
\[ f=\max_{0\leq i\leq n}\operatorname{dist}(\mathbf P_i,\overline{\mathbf A\mathbf B}). \]
Let \(\mathbf S_i\) be the closest chord point to \(\mathbf P_i\). If \(w_i\) are the nonnegative Bézier weights at \(t\), then \(\sum_iw_i\mathbf S_i\) is itself on the chord. The distance from the curve point to the chord is at most \(\|\sum_iw_i(\mathbf P_i-\mathbf S_i)\|\leq\sum_iw_i f=f\). The argument also covers positive-weight rational curves, whose normalized weights are nonnegative.
The distinction matters even on a line. The controls \((0,0),(3,0),(1,0)\) give \(\mathbf B(t)=(6t-5t^2,0)\), with zero perpendicular deviation from the infinite line. The curve reaches \(x=1.8\) at \(t=0.6\) and then returns to \(x=1\). Its maximum chord deviation is 0.8, its length is \(1.8+0.8=2.6\), and the chord length is 1. The finite-chord bound is 2, conservative rather than exact.
function flatten(curve, tolerance, output, depth = 0) {
if (curve.flatness() <= tolerance) {
output.push(curve.end);
return;
}
if (depth === 18) throw new RangeError('Tolerance not reached');
const { left, right } = curve.split(0.5);
flatten(left, tolerance, output, depth + 1);
flatten(right, tolerance, output, depth + 1);
} The tolerance belongs in output space. If one device pixel is the smallest meaningful visual error, a tolerance near half a pixel is a sensible starting point. Zooming or applying a nonuniform transform changes the relevant scale, so flattening solely in object coordinates can violate a screen-space error guarantee. A depth limit prevents unbounded work. The strict example above reports failure if the cap is reached above tolerance; the library returns its best-effort polyline at the cap, so the tolerance guarantee applies only when each accepted piece passed the bound. Positional error is not an arc-length error estimate.
Arc Length and Constant-Speed Travel
The arc length from \(0\) to \(u\) is the speed integral
\[ s(u)=\int_0^u\|\mathbf B'(t)\|\,dt =\int_0^u\sqrt{x'(t)^2+y'(t)^2}\,dt. \]
Generic cubic Bézier arc length has no elementary closed form. Numerical quadrature is therefore normal, not a fallback of last resort. Adaptive Simpson integration and Gauss-Legendre quadrature both work well when paired with explicit error control. Chords from a subdivision give a lower estimate; control-polygon lengths for polynomial children give an upper estimate. Their difference bounds the length error. A small positional flattening tolerance alone does not give that bound.
Red markers use equal increments of \(t\); black markers use equal arc-length increments. Both moving markers finish at the same time. Which one moves farther in the opening second? To move at constant speed, solve \(s(t)=d\) for the desired distance \(d\). Since \(s\) is monotone on a regular curve, bisection is reliable. Repeated animation queries are cheaper with a lookup table of \((t,s)\) pairs followed by local interpolation or Newton refinement.
Separating the Path from Its Timing
A path answers where an object may travel; a timing law answers when it reaches each place. Keeping those questions separate avoids changing the geometry merely to change the speed. Let \(L=s(1)\) and define normalized arc length
\[ \sigma(u)=\frac{s(u)}{L},\qquad U=\sigma^{-1}. \]
A monotone time-distance law \(S:[0,1]\to[0,1]\) then produces the space-time curve
\[ \boxed{\mathbf p(\tau)=\mathbf B\!\left(U(S(\tau))\right)}. \]
The three maps have distinct jobs: \(\mathbf B(u)\) supplies the spatial path, \(U\) converts normalized distance back to the curve parameter, and \(S(\tau)\) controls motion over normalized time. With physical duration \(T\), the speed is
\[ v(\tau)=\frac{L}{T}S'(\tau). \]
Thus \(S(\tau)=\tau\) gives constant speed even when equal parameter increments do not. The cubic smoothstep \(S(\tau)=3\tau^2-2\tau^3\) starts and ends at rest, with \(S'(\tau)=6\tau(1-\tau)\). Its acceleration is not zero at the endpoints; when endpoint acceleration must also vanish, the quintic smootherstep \(6\tau^5-15\tau^4+10\tau^3\) is the usual replacement.
The small markers represent equal time increments. Constant speed spaces the black markers evenly by distance; the red smoothstep markers cluster near both endpoints and spread out near the middle. Acceleration has both a tangential part, controlled by \(S''\), and a normal part caused by curvature: \(\mathbf a=\dot v\,\mathbf T+\kappa v^2\mathbf N\). Consequently, a timing law can smooth changes in speed, but it cannot remove the centripetal acceleration required by a sharply curved path.
CSS cubic-bezier() gives a related inversion problem, not an arc-length calculation. Its endpoints are fixed at \((0,0)\) and \((1,1)\). For a normalized elapsed time \(\tau\), first solve \(x(t)=\tau\), then use \(y(t)\) as progress. In general \(y(\tau)\) gives the wrong answer. Try the inversion with an asymmetric timing curve. For motion through points assigned to absolute times, apply one monotone timing law per path interval and match endpoint velocities when a speed-continuous join is required.
Curvature and Inflections
For a regular planar parametric curve, signed curvature is
\[ \kappa(t)= \frac{x'(t)y''(t)-y'(t)x''(t)}{\left(x'(t)^2+y'(t)^2\right)^{3/2}}. \]
Its magnitude measures turning per unit arc length; its sign records the turning side. Where \(\kappa\neq0\), the osculating circle has radius \(R=1/|\kappa|\) and center \(\mathbf B+(1/\kappa)\mathbf N\) for the chosen normal convention. An ordinary inflection occurs where \(x'y''-y'x''=0\) and the sign changes. Quadratics do not have interior inflections; cubics can have up to two.
A zero derivative is a singular point: tangent normalization and the curvature formula both fail there. Robust code must detect the small denominator rather than allowing infinities to contaminate later geometry.
Projecting a Point onto the Curve
Hit testing, dragging a point on a path, and measuring distance all require the nearest curve point to a query \(\mathbf X\). It minimizes
\[ D(t)=\|\mathbf B(t)-\mathbf X\|^2, \]
whose stationary points satisfy
\[ D'(t)=2(\mathbf B(t)-\mathbf X)\cdot\mathbf B'(t)=0. \]
For a cubic, this is generally a degree-five equation. Isolate every real root in \([0,1]\) by recursively partitioning at the roots of its derivative, refine the sign-changing intervals with bisection, and evaluate \(D\) at every resulting stationary point. Repeated roots occur at derivative boundaries and must be tested explicitly. The endpoints \(t=0\) and \(t=1\) remain candidates because a constrained minimum need not be stationary. Comparing this finite candidate set yields the global nearest point rather than merely the nearest point in a sampled neighborhood. Drag the black query point below.
Molding a Curve
Once projection supplies a parameter \(t\), an editor can let the user grab the curve itself rather than a handle. For a quadratic, solving the Bernstein equation for its only control point is direct:
\[ \mathbf P_1= \frac{\mathbf X-(1-t)^2\mathbf P_0-t^2\mathbf P_2}{2(1-t)t}. \]
A cubic has two unknown controls but only one point constraint, so infinitely many solutions exist. A molding tool must add a policy: preserve the local tangent, minimize control-point displacement, maintain symmetry, or solve a constrained least-squares problem. There is no single geometrically mandatory cubic answer.
const molded = Bezier.quadraticFromPoints(p0, draggedPoint, p2, t); Intersections
Curve and Line
Apply an affine line predicate to the curve, or translate and rotate both objects until the line lies on the x-axis. Intersections then occur where the resulting scalar polynomial is zero. A degree-\(n\) curve produces a polynomial of degree at most \(n\): quadratic curves generally require quadratic root finding and cubic curves require cubic root finding. Retain roots in \([0,1]\), then verify that the corresponding line parameter lies inside the line segment rather than merely on its infinite extension. The complete line-segment intersection follows directly from this predicate.
Keeping the scalar polynomial in Bernstein form adds a useful rejection test: its value lies between its smallest and largest coefficients. If that interval excludes zero, no root exists. On retained intervals, de Casteljau subdivision produces exact child coefficients, while Bézier clipping intersects the coefficient control hull with the zero axis to contract the parameter range more aggressively. These interval methods extend naturally to higher degrees and preserve tangential candidates that endpoint sign-change tests can miss.
Another global construction recursively isolates the roots of the derivative, whose Bernstein coefficients are simply \(n(c_{i+1}-c_i)\) for scalar controls \(c_i\). Those critical parameters partition \([0,1]\) into monotone intervals. Test every critical point itself to retain even-multiplicity roots, and use bisection only on intervals whose endpoint values have opposite signs. Linear, quadratic, and cubic recursion bases can be solved analytically. This gives an explicit parameter tolerance without relying on a fixed sampling density.
Curve and Curve
A robust general strategy uses subdivision and bounding boxes:
- Reject a pair whose bounding boxes do not overlap.
- Split the larger or less flat curve.
- Test the resulting pairs recursively.
- When both boxes are below a geometric tolerance, record a parameter pair.
- Cluster neighboring candidates and refine them with a two-variable solver if higher precision is required.
Tangential contacts are harder than crossings because no sign change occurs. Pure polyline intersection can miss them unless flattening error is included in the acceptance test. Overlapping or coincident curve intervals also require a result model richer than a list of isolated points.
What Subdivision Actually Proves
Disjoint convex hulls are a certificate of non-intersection because each Bézier segment lies in its hull. Overlapping hulls prove only that the pair remains a candidate. Stopping when both boxes are smaller than an arbitrary \(\varepsilon\) can report a near miss as a hit, merge distinct nearby intersections, or return several candidates for one contact. The library method intersects() deliberately has this practical contract: it returns clustered approximate candidates at the requested geometric tolerance, not a topological certificate.
A complete method must distinguish transversal crossings, tangential crossings of odd multiplicity, and tangential non-crossing contacts of even multiplicity. Yap's exact subdivision framework replaces a display-scale cutoff by input-dependent separation bounds. Once a candidate pair is smaller than such a bound, it can contain at most one isolated intersection or relevant critical feature. Elementary convex or concave graph pieces can then be coupled through their normal fields; the signs of the endpoint normal-angle differences decide whether a non-crossing tangency exists. Stationary points, extrema, and inflections must first be isolated so that this elementary-curve criterion applies.
That completeness result assumes exact bigfloat input and requires bounds derived from the degrees and coefficient heights of the original curves. It is substantially more than recursive box overlap, and those guarantees cannot be retrofitted by choosing a smaller floating-point tolerance. Curves sharing a component are a separate output case: their intersection is an interval rather than an isolated parameter pair.
Circle Intersections
For center \(\mathbf C\) and radius \(r\), solve \(\|\mathbf B(t)-\mathbf C\|^2-r^2=0\). A cubic produces a degree-six polynomial, so numerical isolation is the practical route. Partition at derivative roots, retain critical points that satisfy the equation for tangencies, bisect sign-changing monotone intervals, and deduplicate roots within a parameter tolerance.
Offset Curves
An exact constant-distance offset would be
\[ \mathbf O(t)=\mathbf B(t)+d\,\mathbf N(t). \]
The normalized normal contains \(1/\|\mathbf B'(t)\|\), which is generally not polynomial. Consequently, a nontrivial polynomial Bézier curve does not generally have an exact polynomial Bézier offset. Software must approximate it, preserve it as a different curve representation, or flatten it.
The visualization samples exact normal-displaced points; connecting them is only a polyline approximation. A vector workflow usually subdivides at extrema and inflections, approximates simple pieces with new cubics, and checks the geometric error. Large inward offsets can form cusps and self-intersections. Building a stroked outline also requires join and cap policies; offsetting the centerline alone is not enough.
Graduated offsets replace the constant \(d\) by \(d(s)\), preferably as a function of arc length rather than \(t\). This keeps width changes visually uniform even when the curve's parameter speed varies.
The polygonal outline API accepts independent left and right endpoint widths. Each pair is interpolated by the normalized arc length \(s(t)/s(1)\), not directly by \(t\):
const tapered = curve.outline({
left: [0.4, 0.1],
right: [0.2, 0.05]
}, 64); A single number still produces a constant symmetric outline. The profile form permits asymmetric pressure or calligraphic effects while retaining explicit semantics. Both sides are sampled at matching parameters and joined by straight end caps; joins between multiple curve segments remain the caller's responsibility. Pass parameterization: 'parameter' only when variation in \(t\), rather than physical distance, is intentional.
Circular Arcs and Bézier Curves
Polynomial Bézier curves cannot represent a nondegenerate circular arc exactly. A polynomial approximation of a circular arc depends on the degree, endpoint contact order, and geometric error being minimized. The standard cubic construction for an arc of radius \(r\), sweep angle \(\theta\), and endpoint tangents places each internal control a distance
\[ k r,\qquad k=\frac43\tan\frac{\theta}{4} \]
from its endpoint along the tangent. For a quarter circle, \(k\approx0.55228475\). Change the angle below; the reported radial deviation makes the approximation error explicit rather than hiding it behind a smooth stroke.
Split sweeps larger than 90 degrees into multiple segments. If exact conics are required, use rational quadratic Bézier curves: homogeneous weights extend the polynomial basis and can represent circles exactly. If the target format natively supports arcs, retain arcs and convert only at an export boundary.
Approximating a Bézier Curve with Circular Arcs
The reverse conversion is useful for CNC controllers and geometry kernels that prefer lines and arcs. An incenter biarc approximation preserves both endpoints and their tangent directions, then recursively subdivides where radial deviation is largest. For a cubic Bézier spiral, all relevant extrema reduce to quartic equations. General cubics must first be split at singularities, inflections, and curvature extrema before the spiral guarantees can be applied.
Fitting Curves to Data
Control points are not samples the curve generally passes through. Constructing a curve from measured points therefore requires both parameter values and a fitting criterion. A common workflow is:
- Assign parameters by cumulative chord length or centripetal distance.
- Fix endpoints and estimate endpoint tangents.
- Solve a linear least-squares problem for the internal cubic controls.
- Project each sample back onto the curve and update its parameter.
- Repeat until the error stabilizes; split where the tolerance cannot be met.
Equal parameter spacing is simple but performs poorly when samples are uneven. Chord-length parameterization is a better default. For long freehand paths, fitting many cubic segments under a maximum error is more stable than fitting one high-degree curve.
When the target is a known function rather than scattered data, fitting a Bézier curve to its graph can preserve the exact endpoint values and tangent directions. The remaining handle lengths then form a small nonlinear optimization problem whose solution depends on the selected graph-error metric.
Alignment and Numerical Conditioning
Many calculations simplify after translating \(\mathbf P_0\) to the origin and rotating \(\mathbf P_n-\mathbf P_0\) onto the x-axis. Distances, incidences, parameter values, and curve classification are preserved by this rigid transform. Alignment removes constants from component equations and makes baseline distances direct y-coordinates.
Production implementations should also observe the following:
- Compare floating-point values with scale-aware tolerances, not exact equality.
- Detect coincident endpoints before dividing by baseline length.
- Keep parameter tolerances separate from geometric tolerances.
- Use de Casteljau evaluation near difficult configurations instead of expanded high-degree power polynomials.
- Retain parameter intervals during subdivision; geometry without its parameter mapping is insufficient for later refinement.
- Cluster numerical roots and intersections, but do not merge genuinely distinct nearby features merely because the drawing resolution is low.
A Compact JavaScript API
The visualizations use the standalone library at /js/lib/bezier.min.js. It has no DOM dependency and works in a browser or through CommonJS:
const curve = new Bezier([
{ x: 0, y: 0 },
{ x: 1, y: 3 },
{ x: 4, y: 3 },
{ x: 5, y: 0 }
]);
const point = curve.get(0.4);
const tangent = curve.tangent(0.4);
const { left, right } = curve.split(0.4);
const reduced = curve.reduce(2);
const bounds = curve.bbox();
const polyline = curve.flatten(0.25);
const length = curve.length();
const nearest = curve.project({ x: 2, y: 1 });
const molded = Bezier.quadraticFromPoints(p0, pointOnCurve, p2, 0.4);
const svgPath = curve.toSVG();
const powerCoefficients = curve.toPoly();
const strokePolygon = curve.outline(0.2, 64);
const taperedPolygon = curve.outline({ left: [0.2, 0.05], right: [0.1, 0.05] }, 64); const approximation = Bezier.bernsteinApproximation(x => Math.abs(x - 0.5), 12);
const surface = new Bezier.Surface(controlGrid);
const surfacePoint = surface.get(0.4, 0.6);
const tangentU = surface.partialU(0.4, 0.6);
const tangentV = surface.partialV(0.4, 0.6);
const surfaceNormal = surface.normal(0.4, 0.6); const spatialCurve = new Bezier(spatialControls);
const spatialCurvature = spatialCurve.curvature(0.4);
const frame = spatialCurve.frenet(0.4); const quarterCircle = new Bezier.Rational([
{ x: 1, y: 0 },
{ x: 1, y: 1 },
{ x: 0, y: 1 }
], [1, Math.SQRT1_2, 1]);
const exactPoint = quarterCircle.get(0.5); The same API evaluates arbitrary-degree rational curves through homogeneous de Casteljau interpolation. For polynomial curves it provides degree elevation, parameter-space least-squares degree reduction, exact quadratic-to-cubic conversion, construction of a quadratic through a specified point at a specified parameter, curvature, inflection parameters, line and curve intersections, arc-length inversion, sampled offsets, cubic circular-arc approximations, complete four-segment circle approximations, and SVG elliptical-arc conversion with radius correction and flag handling. It also constructs classical Bernstein function approximations and evaluates tensor-product surfaces, their iso-parameter curves, partial derivatives, and unit normals. The geometry code remains separate from Plot.js; rendering is one consumer, not a responsibility of the curve model.
Curves may also be constructed from coordinate pairs, as in new Bezier(0, 0, 1, 3, 4, 3, 5, 0). The aliases eval, getLUT, linearize, subdivide, cut, hodograph, and intersection support familiar terminology without duplicating the underlying algorithms. An outline is a closed polygon assembled from sampled normal offsets; constant symmetric widths and arc-length-interpolated asymmetric profiles use the same representation. It is not presented as an exact polynomial offset curve.
Practical Checklist
- Evaluate with de Casteljau when stability and arbitrary degree matter.
- Evaluate rational curves in homogeneous coordinates and divide only after the final interpolation.
- Use quadratic or cubic segments for editable paths, not one very high-degree curve.
- Evaluate tensor-product surfaces by applying de Casteljau successively in both parameter directions.
- Split adaptively and measure error in the coordinate space that matters to the output.
- Find exact axis-aligned bounds from derivative roots.
- Use numerical quadrature for length and a lookup table for repeated constant-speed traversal.
- Treat projection and intersections as root-isolation problems with explicit tolerances.
- Remember that offsets and ordinary circular arcs are not polynomial Bézier curves.
- Distinguish geometric continuity from parametric continuity at joins.
References
- [Farin2002]Gerald Farin, Curves and Surfaces for CAGD: A Practical Guide, fifth edition, Morgan Kaufmann, 2002.
- [SederbergNishita1990]Thomas W. Sederberg and Tomoyuki Nishita, Curve Intersection Using Bézier Clipping, Computer-Aided Design 22(9), 1990.
- [Yap2006]Chee K. Yap, Complete Subdivision Algorithms, I: Intersection of Bézier Curves, Proceedings of the 22nd Annual Symposium on Computational Geometry, 2006.
- [StoneDeRose1989]Maureen C. Stone and Tony D. DeRose, A Geometric Characterization of Parametric Cubic Curves, ACM Transactions on Graphics 8(3), 1989.