1 Definition and Mathematical Foundations

Degree elevation is a transformation of a parametric geometric entity—most commonly a Bézier curve or surface—into an equivalent representation with a higher polynomial degree, while preserving the set of points traced in space for each parameter value. In practice, the algorithm changes the basis decomposition (e.g., the control net) so that the elevated form reproduces the same geometry.

1.1 Polynomial Degree and Parametric Representations

A parametric curve in CAGD is typically written in the form \[ \mathbf{C}(t)=\sum_{i=0}^{n} \mathbf{P}_i\, B_{i,n}(t), \] where \(B_{i,n}(t)\) are basis functions of degree \(n\), \(\mathbf{P}_i\) are control points, and \(t\) lies in a parameter interval (often \([0,1]\) for Bézier representations). The polynomial degree \(n\) determines how many basis functions are used and how the curve responds to changes in control coefficients.

Degree elevation replaces the degree \(n\) basis expansion with a higher-degree basis expansion, for example: \[ \mathbf{C}(t)=\sum_{j=0}^{n+1} \mathbf{P}'_j\, B_{j,n+1}(t), \] such that \(\mathbf{P}'_j\) define an equivalent curve.

For surfaces, the same idea applies independently in each parametric direction. A common tensor-product setting uses a double sum over degrees \((n,m)\) along parameters \((u,v)\).

1.2 Bézier Curves: From Degree n to Degree n+1

For Bézier curves, the basis functions are Bernstein polynomials: \[ B_{i,n}(t)=\binom{n}{i} t^i (1-t)^{n-i}. \] A degree-\(n\) Bézier curve is defined by control points \(\mathbf{P}_0,\ldots,\mathbf{P}_n\): \[ \mathbf{C}(t)=\sum_{i=0}^{n} \mathbf{P}_i\, B_{i,n}(t). \] Degree elevation seeks a new set \(\mathbf{P}'_0,\ldots,\mathbf{P}'_{n+1}\) such that: \[ \mathbf{C}(t)=\sum_{j=0}^{n+1} \mathbf{P}'_j\, B_{j,n+1}(t) \] for all \(t\) in the parameter domain. The endpoints of a Bézier curve are interpolation points in both representations, so \(\mathbf{P}'_0=\mathbf{P}_0\) and \(\mathbf{P}'_{n+1}=\mathbf{P}_n\), reflecting the shared boundary behavior.

1.3 Control Points Transformation

Degree elevation changes the control points by a linear transformation. For curves, each elevated control point \(\mathbf{P}'_j\) is computed as a convex combination of adjacent original control points: \[ \mathbf{P}'_j = \alpha_j \mathbf{P}_{j-1} + (1-\alpha_j)\mathbf{P}_j,\quad j=1,\ldots,n, \] with appropriate values at the boundaries (\(j=0\) and \(j=n+1\)). This adjacency property follows from the overlap structure of Bernstein polynomials when increasing degree by one.

Conceptually, the transformation redistributes “influence” of the original control points across the denser control polygon of the elevated curve while maintaining identical geometry.

1.4 Basis Function Relationships

The mathematical backbone of degree elevation is an identity relating Bernstein polynomials of different degrees. One standard form expresses a degree-\(n\) Bernstein basis as a combination of degree-\(n+1\) bases: \[ B_{i,n}(t) = \frac{i+1}{n+1} B_{i+1,n+1}(t) + \frac{n-i+1}{n+1} B_{i,n+1}(t). \] Substituting this into the original curve expression yields the control-point transformation for the elevated curve. Equivalent relationships exist for tensor-product surfaces, where the elevation in one direction can be derived from the one-dimensional Bernstein identity and applied consistently along the other direction.

These basis relationships ensure exact shape invariance in exact arithmetic and provide the coefficients needed for stable numerical computation.

2 Algorithms and Implementation Details

Implementations typically follow a clear workflow: (1) identify the original representation (degree, control net layout, and parameterization), (2) compute elevated control points using closed-form coefficient formulas or matrix relations, (3) store the elevated representation with updated degree and control array sizes, and (4) optionally verify equivalence through sampling or basis identity checks.

2.1 Degree Elevation for Bézier Curves

A degree elevation by one maps \(n+1\) control points to \(n+2\) control points. Efficient implementations use coefficient formulas rather than reconstructing geometry samples.

2.1.1 Computing Elevated Control Points

For a curve of degree \(n\) with control points \(\mathbf{P}_0,\ldots,\mathbf{P}_n\), the elevated control points for degree \(n+1\) are:

  • \(\mathbf{P}'_0 = \mathbf{P}_0\)
  • \(\mathbf{P}'_{n+1} = \mathbf{P}_n\)
  • for \(j=1,\ldots,n\):

\[ \mathbf{P}'_j = \frac{j}{n+1}\mathbf{P}_{j-1} + \left(1-\frac{j}{n+1}\right)\mathbf{P}_j = \frac{j}{n+1}\mathbf{P}_{j-1} + \frac{n+1-j}{n+1}\mathbf{P}_j. \]

This formula generalizes naturally for vector-valued control points (positions), and it can be applied component-wise.

2.1.1.1 Handling Numeric Precision and Stability

Although the formulas are linear, precision issues arise in floating-point arithmetic for large \(n\) or when coordinates vary widely in magnitude. Practical strategies include:

  • compute coefficients (e.g., \(j/(n+1)\)) in double precision even if inputs are single precision;
  • avoid repeated recomputation inside tight loops by precomputing coefficient arrays;
  • consider fused multiply-add operations when available to reduce rounding error in expressions like \(\alpha \mathbf{P}_{j-1} + (1-\alpha)\mathbf{P}_j\);
  • preserve boundary assignments exactly (copying \(\mathbf{P}_0\) and \(\mathbf{P}_n\)) rather than recomputing them.

For very high degrees, accumulated rounding can slightly perturb the equivalence. In such cases, validation by curve evaluation at representative parameter values is recommended.

2.1.2 Complexity and Performance Considerations

Degree elevation by one for Bézier curves is \(O(n)\) in the number of control points: each of the \(n\) interior elevated points depends on two original points, and endpoints are direct copies. Memory usage increases by one control point, requiring allocation for \(n+2\) points.

For bulk operations (many curves), performance benefits from:

  • batching coefficient computation;
  • using contiguous array layouts for control points;
  • minimizing dynamic allocations inside per-curve loops.

2.2 Degree Elevation for Bézier Surfaces

A tensor-product Bézier surface of degrees \((n,m)\) has control points \(\mathbf{P}_{i,j}\) for \(i=0..n\) and \(j=0..m\), with: \[ \mathbf{S}(u,v)=\sum_{i=0}^{n}\sum_{j=0}^{m}\mathbf{P}_{i,j}\, B_{i,n}(u)B_{j,m}(v). \] Elevating the degree in one direction increases the count in that parametric axis, leaving the other axis unchanged.

2.2.1 Elevating in One Parametric Direction

To elevate in the \(u\)-direction (degree \(n \rightarrow n+1\)), transform each “row” of control points across \(i\) while holding \(j\) fixed: \[ \mathbf{P}'_{i,j} \quad \text{computed from}\quad \mathbf{P}_{i-1,j}, \mathbf{P}_{i,j}. \] Concretely, for \(i=0\) and \(i=n+1\) copy endpoints; for interior indices use the same coefficient structure as the curve case, with \(n\) replaced by the surface’s \(n\).

Complexity is linear in the number of control points along the elevated axis, resulting in \(O((n+1)(m+1))\) operations for one elevation direction (up to constant factors from vector dimensions).

2.2.2 Elevating in Both Parametric Directions

Elevating in both directions \((n,m)\rightarrow(n+1,m+1)\) can be done sequentially:

  1. elevate all control points in the \(u\)-direction to produce an intermediate net of degree \((n+1,m)\);
  2. elevate the resulting net in the \(v\)-direction to obtain degree \((n+1,m+1)\).

Since the transformations are linear and independent across parametric directions in tensor-product form, sequential application yields the same result as simultaneous elevation, while keeping implementation simple.

2.3 Multi-Step Elevation (Elevate by k Degrees)

Degree elevation is often applied repeatedly until a desired degree is reached, such as aligning with another geometry object’s degree.

2.3.1 Repeated Elevation vs Direct Computation

There are two general approaches:

  • Repeated elevation: apply the degree-by-one algorithm \(k\) times.
  • Direct computation: compute elevated control points for degree \(n+k\) using a closed-form coefficient involving binomial terms or a precomputed elevation matrix.

Repeated elevation is straightforward and typically stable for moderate \(k\), but it increases runtime by a factor of \(k\). Direct computation can be more efficient for large \(k\) but may involve larger binomial coefficients and potential numeric instability if coefficients are not handled carefully.

A common implementation choice is:

  • use repeated elevation for small \(k\);
  • use direct or matrix-based approaches when \(k\) is large and coefficients are computed with numerically robust methods (e.g., normalization to avoid overflow).

2.4 Practical Pseudocode and Reference Procedures

Below is a reference-style procedure for Bézier curves (degree elevation by one). It assumes 0-based indexing and control points are stored as vectors.

Degree elevation by one for Bézier curves

  • Input: degree \(n\), control points \(P[0..n]\)
  • Output: \(P'[0..n+1]\)
  1. Set \(P'[0] = P[0]\)
  2. For \(j = 1\) to \(n\):
  • \(\alpha = j/(n+1)\)
  • \(P'[j] = \alpha\cdot P[j-1] + (1-\alpha)\cdot P[j]\)
  1. Set \(P'[n+1] = P[n]\)

For surfaces, the curve routine is applied across one index dimension with nested loops over the other index.

3 Use Cases in Software Engineering

In engineering toolchains, degree elevation acts as a compatibility bridge: it changes representation order while leaving geometry invariant, which is useful for algorithms that assume a particular polynomial degree or basis layout.

3.1 Representation Alignment in Geometry Pipelines

Many geometry pipelines contain modules that operate under specific assumptions—such as expecting a fixed degree, or using shared basis degrees for blending, fitting, or conversion steps. When two curves of different degrees must be combined, elevated representations provide a common basis degree without altering the original shapes.

For example, blending operations or constraint solvers that use linear combinations of control points may be simplified by first elevating both inputs to the same degree.

3.2 Interoperability Between Tools and Libraries

CAD/CAM kernels, geometry processing libraries, and rendering systems frequently represent curves using different standard forms or at different degrees. Degree elevation helps reconcile these differences during import/export, conversion, or normalization steps.

Rather than approximating geometry or re-fitting control points, the elevation technique preserves exact shape (subject to floating-point error), making it suitable for pipelines where fidelity matters.

3.3 Curve Editing, Construction, and Constraint Solving

Interactive curve editing sometimes performs operations that implicitly increase polynomial complexity—for instance, after certain constraint transformations or staged constructions. Degree elevation can maintain a consistent internal representation while keeping constraints meaningful in control space.

In constraint-solving workflows, aligning degrees can also improve numerical behavior by ensuring that derived equations relate compatible control coefficients.

3.4 Data Preparation for Subdivision and Rendering

Subdivision schemes and certain rendering approximations may work more predictably on curves and surfaces with particular degrees. Elevating the degree can prepare geometry for downstream steps such as hierarchical refinement, feature extraction, or adaptive tessellation.

3.4.1 Adaptive Refinement Strategies

Adaptive refinement often uses error estimates computed from evaluations or from control net characteristics. Degree elevation can be used to standardize the form used by the estimator, particularly when mixing segments produced by different upstream operations.

Even when refinement ultimately samples the curve, having a consistent polynomial basis can reduce special-casing in the codebase.

4 Degree Elevation with Splines and NURBS

While degree elevation is often introduced for Bézier forms, spline-based representations extend the concept to piecewise polynomial spaces. Many CAGD systems translate spline segments into Bézier form for processing, apply elevation, and then convert back.

4.1 Relationship to B-Splines and Knot Insertion

B-splines represent curves via a control polygon and a knot vector. Degree elevation for splines is closely connected to operations that change degree and/or insert knots so that the refined spline space supports a representation of the same geometric curve.

A typical pipeline is:

  1. decompose the spline into Bézier segments (often via knot insertion to reach Bézier-friendly knot multiplicities);
  2. elevate degrees on each Bézier segment;
  3. reassemble into an equivalent spline representation if needed.

This relation clarifies that degree elevation can be achieved without changing geometry by working within the appropriate basis transformation between polynomial spaces.

4.2 NURBS Considerations (Homogeneous Coordinates)

NURBS (Non-Uniform Rational B-Splines) add weights to handle conic sections and other rational shapes. Degree elevation in NURBS commonly operates in homogeneous coordinates: \[ \mathbf{X}(t) = \big(w(t)\mathbf{p}(t),\, w(t)\big), \] so that rational behavior becomes polynomial in the augmented space. Control points in homogeneous form are elevated similarly to polynomial control points, and the result is mapped back to Euclidean coordinates by dividing by the weight.

This ensures that both the shape and the rational structure are preserved, rather than merely elevating positions while leaving weights inconsistent.

4.3 Degree Elevation vs Degree Reduction

Degree reduction (lowering degree) is generally not shape-preserving: it seeks an approximation with fewer control coefficients. In contrast, degree elevation is exactly geometry-preserving (again, up to numerical error) because it refines the basis representation without changing the underlying polynomial/rational function.

Consequently, many systems prefer degree elevation as a safe compatibility step, while using degree reduction only when approximation is acceptable or desired.

5 Testing, Validation, and Edge Cases

Correct degree elevation should maintain geometric equivalence across the entire parameter domain.

5.1 Shape Invariance Checks

A common validation method evaluates both original and elevated representations at a set of parameter values \(t_k\) (or \((u_k,v_k)\) for surfaces) and compares:

- positions: \(\|\mathbf{C}(t_k)-\mathbf{C}'(t_k)\|\);
- optionally derivatives: \(\|\mathbf{C}'(t_k)-\mathbf{C}'_{\text{elev}}(t_k)\|\), since basis transformations preserve differentiability properties.

Because Bernstein bases form a partition of unity, exact invariance is expected in exact arithmetic, but floating-point discrepancies may appear, especially at high degrees.

5.2 Parameterization Consistency

Degree elevation assumes the same parameter interval and basis interpretation. Validation should confirm that:

  • the elevated curve uses the same parameter domain and orientation;
  • surface elevation preserves correspondence between \(u\) and \(v\) indices (no accidental transposition);
  • control net indexing conventions match the library’s expected ordering.

Such issues often present as consistent but scaled or mirrored deviations.

5.3 Degenerate and Boundary Cases

Boundary behavior is a natural edge case for algorithms because it involves copying endpoint control points and computing interior convex combinations.

5.3.1 Extremely High Degrees

For very large degrees, several risks increase:

  • coefficient computations may overflow if implemented with raw binomial terms;
  • rounding errors may accumulate with repeated elevation;
  • memory usage grows linearly with degree, potentially stressing systems that batch many curves.

Mitigation often involves:

  • using stable coefficient formulations that avoid large intermediate values;
  • limiting repeated steps by using direct elevation where appropriate;
  • performing equivalence checks on representative parameter samples rather than relying solely on coefficient arithmetic.

5.4 Regression Tests and Golden Master Data

Engineering teams typically include regression tests that:

  • compare elevated vs. original evaluations at predetermined parameter grids;
  • check control point transformations for known degrees where coefficients are simple;
  • store “golden master” results for a curated set of curves and surfaces to detect drift after changes to math kernels or serialization.

Golden masters are particularly effective because they capture library-specific conventions.

6 Performance and Numerical Robustness

Degree elevation is mathematically linear, but performance and robustness depend heavily on implementation details and numeric handling.

6.1 Floating-Point Error Sources

Primary error sources include:

  • rounding during coefficient multiplication and addition;
  • catastrophic cancellation when coefficients are close to 0 or 1 and points are far apart in magnitude;
  • repeated elevation amplifying rounding at each step;
  • inconsistent precision between coefficient computation and control-point storage.

Using higher precision for coefficients and careful arithmetic order can reduce these errors.

6.2 Conditioning and Scaling Strategies

The conditioning of the control-point transformation is generally favorable because each elevated control point is a weighted average of existing ones. However, conditioning can degrade when control points are extremely large or when the curve is nearly degenerate (e.g., points nearly collinear or identical), causing small differences to dominate the error.

Scaling strategies include:

  • normalizing control point magnitudes temporarily (then denormalizing after elevation);
  • using consistent units and coordinate ranges across the pipeline;
  • ensuring that input control points are stored with adequate precision.

6.3 Benchmarking Methodology

Performance benchmarking should measure:

  • runtime per curve/surface as a function of degree;
  • memory allocations and peak resident memory for batched elevation;
  • equivalence error metrics versus degree and versus number of repeated steps.

A robust methodology uses representative datasets (varied degrees and control-net shapes) and compares implementations (e.g., repeated vs. direct elevation, curve-only vs. surface elevation).

7 Integration Considerations

Integrating degree elevation into software requires consistent data modeling, stable APIs, and compatibility with interchange formats.

7.1 API Design for Geometry Kernels

A geometry kernel API often exposes degree elevation as a pure transformation:

  • input: geometry object and target degree (or increment \(k\));
  • output: new geometry object with updated degree and control data.

Good API design clarifies:

  • whether elevation is performed in-place or returned as a new object;
  • how basis type is specified (Bézier vs. spline vs. NURBS);
  • how parameter domains and knot vectors are preserved or updated.

7.2 Data Structures for Control Points and Weights

Representations differ by basis:

  • Bézier curves: a flat array of control points.
  • Bézier surfaces: a 2D grid (or flattened 1D with a fixed indexing scheme).
  • NURBS: control points plus weights, frequently stored together in homogeneous form for efficiency.

Implementations should align memory layout with access patterns (e.g., row-major vs. column-major traversal) to reduce cache misses during coefficient application.

7.3 Serialization/Interchange Formats

When degree elevation is used during import/export, serialization must preserve:

  • degree metadata;
  • control point ordering;
  • surface indexing conventions;
  • weights for NURBS.

Mismatches in ordering can cause apparent shape changes even when the math is correct, so interchange layers should include clear contracts and automated validation.

7.4 Toolchain Compatibility (CAD/CAM, Graphics, Geometry Processing)

Degree elevation is commonly used in toolchains that combine multiple stages:

  • CAD modeling outputs curves at certain degrees;
  • CAM planning expects a specific representation for offsetting, sampling, or toolpath generation;
  • rendering pipelines convert geometry for tessellation and shading.

Degree elevation can act as an adapter stage, enabling modules to work with uniform assumptions without forcing lossy approximations.

Degree elevation sits within a broader set of representation and refinement operations used to manipulate parametric geometry.

8.1 Curve Refinement and Subdivision

Subdivision splits a curve or surface into smaller pieces using evaluation rules (e.g., De Casteljau-based methods). While subdivision increases geometric detail locally, degree elevation increases polynomial degree globally without changing the curve.

Both are often used together in adaptive workflows: elevation for representational alignment and subdivision for localized refinement.

8.2 Degree Raising in Computer-Aided Geometric Design

Degree raising is another term often used interchangeably with degree elevation, emphasizing that the polynomial order increases while preserving geometry. In spline contexts, degree raising is connected to knot vector transformations and basis re-expression.

8.3 Basis Conversion Techniques

Degree elevation is a particular basis conversion between Bernstein bases of different degrees. Related operations include:

  • converting between Bézier and B-spline forms,
  • knot insertion and knot removal (with associated basis changes),
  • transforming between polynomial and rational (NURBS) forms via homogeneous coordinates.

Reading these topics alongside degree elevation clarifies how many geometry algorithms are basis-agnostic when expressed as linear combinations in the correct function space.