Direct Degree Elevation of NURBS

For the specific topic of this section, the multiplicity knot vector representation is used, and consequently any degenerated polynomial piece of zero domain interval is not counted as one segment.

This section gives an algorithm that develops NURBS degree elevation with any amount in a single step. Since degree elevation of a NURBS surface is basically done in each direction, in exactly the same as a NURBS curve, we only consider NURBS curves in the following.

Let $b(t_1, \cdots, t_d)$ be the blossom of some NURBS segment. Define another symmetric multi-affine mapping as,

$$\bar{b}(t_1, \cdots, t_{d+n}) = \frac{\sum_{I \in I_{n+d}, \Vert I\Vert = d}b(t_I)} {{d+n\choose d}},$$ (9)

where $I_n$ is the index set,

$$I_n = \{1, 2, \cdots, n\},$$

and $(t_I)$ stands for $(t_{k_1}, \cdots, t_{k_d})$ , where $I = \{k_1, \cdots, k_d\}$ .

From the specific construction of $\bar{b}$ , obviously its diagonalization is a NURBS segment that degree raises the original one by the amount of $d$ .

Now coming back to the actual NURBS to be degree raised by an amount of $d$ , i.e. we should construct the above symmetric multi-affine mapping for each single segment, find the control points of each, and join all these seperate pieces together. It turns out that we can just compute the new control points regardless of the knowledge which segments of the computed control points are defined for; the interpolation scheme in the algorithm below actually automatically makes this always correct.

Suppose the original knot vector has distinct ascending knot values,

$$t_0, \cdots, t_s,$$

and multiplicities,

$$m_i <= d$$ for $$i = 0, \cdots, s, \nonumber$$

Suppose further this NURBS is to be degree raised by an amount of $n$ , then the degree raised NURBS has the same distinct knot values, but with the mulitplicities increased by $n$ for each knot value, i.e.,

$$\bar{m}_i = m_i + n$$ for $$i = 0, \cdots, s, \nonumber$$

And with the knowledge of the knot vector of the degree raised NURBS, and Eq. (12), the new control points can be computed from the corresponding points of the original NURBS blossom, which are usually not in the original control points and therefore need to be interpolated from them. The new control knot vector has each multiplicity raised by $d$ , and the knot sequence in each term of the right side of Eq. (12) has total $d$ knots removed; hence, the knot sequence in each term of the right side of Eq. (12) is either a sequence exactly from the original knot vector, or a sequence of the original knot vector with some knots inserted - either case, it is well defined and the interpolation make sense.²

With the proper iteration method on control mesh and knot sequence defined, Algorithm 1 implements a direct general dimensional NURBS degree elevation.

Algorithm 1  

Direct Degree Elevation of a General Dimensional NURBS

Input: 

$\bf {x}$
, the tensor NURBS of any dimension to degree raised in some direction. 

$\bf {i}$
, the direction along which the given NURBS is to be degree raised. 

$\bf {d}$
, the original degree in direction $\bf {i}$
 of $\bf {x}$
.

$\bf {n}$
, the amount of degree elevation.

Output: 

$\bf {x}$
, the degree raised NURBS.

Begin 


convert $\bf {x}$
 to open end condition in direction $\bf {i}$
. 


raise the knot multiplicity of $\bf {x}$
 by $\bf {n}$
 for each knot value. 


knot-sequence-iterate through the new knot vector and through the slices (across direction $\bf {i}$
) of control points as well, 


extract consecutive $\bf {n+d}$
 knot values, $\bf {Seq}$
, in each iteration, 


initialize the new control points of the whole current slice to the zero value in the appropriate affine space. 


degree-reduce-iterate over $\bf {Seq}$
, extract a sequence of $\bf {d}$
 knot values, $\bf {seq}$
, in each iteration, 


for each control point in the current slice, 


add it the blossom value of $\bf {x}$
 at $\bf {seq}$
 by interpolation on the original control points. 

(this is typically done with a blossom table).  


divide each control point in the current slice by the nubmer of total iterations above.

End