Outline

• Bezier Curves and B-splines
• Quiz
• Degree Elevation
• Rational B-splines and NURBS
• OpenGL

Introduction

• Last week, we were talking about B-splines.
• We discussed the de Boor algorithm for finding points on a B-spline
• We talked about blossoms and how they could be used to find control points and prove facts about derivatives of B-splines and knot insertion.
• Today, we will talk about the connection between piecewise Bezier Curves and B-splines, degree elevation of B-splines, NURBS, and OpenGL for B-splines.

From Bezier Curves to B-splines

• We already gave the example last week of how to convert a degree three Bezier Curve `\vec q(u)` with control points `\vec p_0`, `\vec p_1`, `\vec p_2`, `\vec p_3` to a B-spline.
• Namely, use the same control points, and take ones knot vector to be `[0,0,0,0, 1, 1, 1, 1]`
• This example was a special case of a more general result:
  Theorem. Let `k\geq 1` and `\vec q(u)` be a degree `k`-Bezier curve defined by control points `\vec p_0, \vec p_1, \ldots, \vec p_k`. Then `\vec q(u)` is identical to the degree `k`-B-spline curve defined with the same control points over the knot vector consisting of the 0 knot with multiplicity `k+1` followed by the 1 knot with multiplicity `k+1`.
• To prove the theorem one shows by induction on `k` in the de Boor formula that when one has a knot vector of the form `[0^{\langle k+1\rangle}, 1^{\langle k+1\rangle}]` the blending functions will be:
  `N_(i, k+1)(u) = ((k),(i))u^i(1-u)^(k-1)`,
  that is, exactly the blending functions of a Bezier curve.

Patching together multiple Bezier Curves

• It is possible to combine two of more Bezier Curves into a single B-spline curve.
• For example, if we have degree two Bezier curves `\vec q_1(u)` and `\vec q_2(u)` with control points `\vec p_0`, `\vec p_1`, `\vec p_2`, and `\vec p'_0`, `\vec p'_1`, `\vec p'_2`, we can use the theorem of the last slide to make a single B-spline which consists of `\vec q(u) = \vec q_1(u)` for `0\leq u \leq 1` followed by `\vec q(u) = \vec q_2(u)` for `1\leq u \leq 2`, provided `\vec p_2=\vec p'_0`.
• To do this we just take the same size control points and the knot vector `[0,0, 0, 1, 1, 1, 2, 2, 2]`
• Alternatively, since `\vec p_2=\vec p'_0`, we can use the five control points `\vec p_0`, `\vec p_1`, `\vec p_2`, `\vec p'_1`, `\vec p'_2` and the knot vector `[0, 0, 0, 1, 1, 2, 2, 2]`.
• This technique generalizes to chaining more than two curves as well as to higher degree curves.

From B-spline Curves to Piecewise Bezier Curves

• We have already given an algorithm to allow us to do knot insertion for B-splines.
• To convert a degree `k` B-spline into a series of piecewise Bezier Curves, we can use repeated knot insertion to insert multiple occurrences of the same knots, until the first and last knots have multiplicity `k+1` and all the other internal knots have multiplicity `k`.
• The control points of the resulting B-spline curve will then also be the control points for Bezier curves between the knot positions.

Quiz

Which of the following statements is true?

1. The Bohm algorithm is an analog of de Casteljau method for Blossoms.
2. The de Boor algorithm does not make use of linear interpolation.
3. Given the polynomial curve between two knots of a B-spline, a blossom can be use to calculate the control points.

Degree Elevation

• We gave for Bezier curves a way to go from a degree `k` curve to the control points for an identical degree `k+1` curve.
• We now consider the same problem for B-splines. Suppose we are given a degree `k` B-spline curve `\vec q(u)` and we wish to find a way to describe the same curve as a degree `k+1` B-spline.
• One problem is if a knot `u` has multiplicity `\mu` in the degree curve, then `\vec q(u)` has continuous `(k - \mu)` derivative at `u` but might not have continuous `(k - \mu +1)`th derivative -- the latter being needed if degree elevation is to work.
• So to elevate the degree of the curve one generally needs to increase the multiplicity of all knots by one.
• The book gives several references for algorithms to do degree elevation, we will only mention the basic strategy...
• First add knots, so that all knots have multiplicity `k` in order to convert the curve into a degree `k` Bezier curve segments. Next use degree elevation for these Bezier segments to make degree `k+1` segments and get the associated B-spline. Finally, reduce the knot multiplicities via a process called "knot elimination".

Rational B-splines and NURBS

• A B-spline curve is called a rational curve if its control points are specified with homogeneous coordinates.
• NURBS are nonuniform, rational B-splines.
• Much of the material we already discussed about rational Bezier curves also applies to rational B-splines and NURBS.
• A rational B-spline has 4-tuples `\langle x,y,z,w \rangle` as control points; and the curve's values `\vec q(u)` are expressed as weighted averages of the control points,
  `\vec q(u) = \sum_iN_(i,m)\vec p_i`.
• As with rational Bezier curves, the `w` component acts as a weight factor: A control point `\langle w\vecP_i, w\rangle` weights the point `\vec p_i` by a factor of `w`.
• As with the Bezier case, rational B-splines are preserved under perspective transformations. They also may have points at infinity.

Conic Sections

• We showed how Bezier curves can be used to trace out portions of a conic section such as a semi-circle.
• A single B-spline can be used to define an entire circle or an entire conic section.
• The basic idea to do this is to use our technique from earlier today for combining several Bezier curves into one B-spline.
• For instance, to create a circle, we could use the control points rational Bezier Curves for the left and right semi-circles: `\langle 0, 1, 1 \rangle, \langle 1, 0, 0 \rangle, \langle 0, -1, 1 \rangle, \langle -1, 0, 0 \rangle, \langle 0, 1, 1 \rangle` together with the knot vector `[0,0,0, 1, 1, 2, 2, 2]`.
• The circle drawn above was created by taking the knot vector [0,0,0, 1, 1, 2, 2, 3, 3, 4, 4, 4], starting with the rational Bezier curve for each quarter. These curves have weight 1 for the control points on the curve and weight `\frac{\sqrt(2)}{2}` otherwise.

B-splines and NURBS in OpenGL

• Both B-splines and NURBS can be drawn in OpenGL using glu calls.
• The basic sequence of calls to draw a B-spline is:

  GLUnurbsObj *curveName;
  curveName = gluNewNurbsRenderer();
  gluBeginCurve(curveName);
    gluNurbsCurve(curveName, nknots, *knotVector, stride, 
       *ctrtPts, degParam, GL_MAP1_VERTEX3); 
    //GL_MAP1_VERTEX4 for homogeneous coordinates
  gluEndCurve(curveName);
  

• You can define the curve using multiple calls to gluNurbsCurve. The curve is drawn when gluEndCurve is called.
• Once done with a curve you can call gluDeleteNurbsRenderer(curveName); to delete it.
• Rendering options for drawing the curve can be set using a call to gluNurbsProperty(splineName, property, value);

GLU B-spline Surface Functions

• The basic sequence of calls to generate a B-spline surface is:

  GLUnurbsObj *surfaceName;
  surfaceName = gluNewNurbsRenderer();
  
  gluNurbsProperty(surfaceName, property1, value1);
  gluNurbsProperty(surfaceName, property2, value2);
  gluNurbsProperty(surfaceName, property3, value3); //...
  
  gluBeginSurface(surfaceName);
    gluNurbsSurface(surfaceName, nuknots, *uknotVector, nvKnots,
       *vKnotVector, uStride, vStride, 
       &ctrlPts[0][0][0], uDegParam, vDegParam, GL_MAP2_VERTEX3);
  gluEndSurface(surfaceName);
  

• Examples of properties one might set are things like:
  gluNurbsProperty(surfaceName, GLU_NURBS_MODE, GLU_NURBS_TESSELLATOR);
  or
  gluNurbsProperty(surfaceName, GLU_DISPLAY_MODE, GLU_OUTLINE_POLYGON);