Outline

• Example OpenGL Program
• Quiz
• Hermite Polynomials
• Bézier Curves of General Degree

Introduction

• Last week, we started studying Bezier Curves as a useful tool in geometric modeling.
• Bezier curves allow us to describe curves using a fixed number of points.
• This is useful because we can build up the drawing of an object using such points.
• We concentrated on degree three Bezier curves and gave De Casteljau's Method as a means for calculating points on such curves.
• We discussed how to subdivide a curve into two smaller curves and gave applications for this.
• Finally, we talked about conditions to "nicely" attach one Bezier curve to another.
• Today, we are going to give a very simple OpenGL program drawing Bezier curves to remind ourselves about OpenGL.
• Then we are going to extend the methods we had from last day for degree 3 Bezier curves to higher degree.

Example OpenGL Program

/******************************************************
 * Project:         CS216 Bezier Test
 * File:            main.cpp          
 * Purpose:         Code to point plot a simple Bezier Curve
 * Start date:      Feb. 1, 2010
 * Programmer:      Chris Pollett
 *
 * Remarks: Adapted from Hearn and Baker (3rd edition)
 *
 *******************************************************/

#ifdef WIN32
#include <GL/glut.h>
#endif

#ifdef __APPLE__ //for MAC
/*
 I created my project under xcode. I chose new C++ tool as the kind of project.
 Then I added the two frameworks:
 OpenGL.framework and GLUT.framework. (Frameworks are in /Library/Frameworks)
 
 */
#include <OpenGL/gl.h> 
#include <OpenGL/glu.h>
#include <GLUT/glut.h>
#endif

#ifdef linux // for linux
/*My compile line was:
 g++ -I /usr/X11R6/include -L /usr/X11R6/lib -lglut -lGL \
 -lGLU -lX11 -lXmu -lXi -lm name.cpp -o name
 */
#include <GL/glut.h>
#include <GL/glu.h>
#endif

#include <cstdlib>
#include <cmath>
#include <iostream>

using namespace std;

/*
 CLASS DEFINITIONS
*/

/*-----------------------------------------------*/
class Point2D
/*
 PURPOSE: Encapsulates the notions of a point (x,y) on the screen
*/

{
  public:
    GLfloat x, y;	 
};

/*-----------------------------------------------*/
void plotPoint (Point2D p)
/*
 PURPOSE: plots a point in 2D
 RECEIVES: p the point object to plot
 RETURNS: nothing
 REMARKS:    
 */
{
	glBegin(GL_POINTS);
	   glVertex2f(p.x, p.y);
	glEnd();
}

/*-----------------------------------------------*/
void binomialCoefficients(GLint n, GLint *C)
/*
 PURPOSE: fills in a reference with binomial coefficient values
 RECEIVES: n - says we will compute n choose k for k <= n
           C - reference to fill in with these values
 RETURNS: nothing
 REMARKS:    
 */
{
	GLint k;
	GLint j;
	
	for(k = 0; k <= n; k++) 
	{
		C[k] = 1;
		for (j = n; j >= k + 1; j--)
		{
			C[k] *= j;
		}
		
		for (j =n - k ; j >= 2; j--) {
			C[k] /= j;
		}
	}
}

/*-----------------------------------------------*/
void computeBezierCurvePoint(GLfloat u, Point2D *p, GLint nCtrlPts, Point2D *ctrlPts, GLint *C)
/*
 PURPOSE: computes a point on the given Bezier Curve
 RECEIVES: u -  a value between 0, 1 saying when on the curve
           p - address of a point to hold the result
		   nCtrlPts - number of control points in the curve
           ctrlPts - reference to the actual control points
		   C - array storing binomial coefficients.
 RETURNS: nothing
 REMARKS:    
 */
{
	GLint k; 
	GLint n = nCtrlPts - 1;
	GLfloat blendingFunction;
	
	p->x = 0.0;
	p->y = 0.0;
	
	for (k=0; k < nCtrlPts; k++) {
		blendingFunction = C[k] * pow(u, k) * pow(1 - u, n - k);
		p->x += ctrlPts[k].x * blendingFunction;
		p->y += ctrlPts[k].y * blendingFunction;		
	}
	
	
}

/*
 GLUT AND DRIVER CODE
 */

/*-----------------------------------------------*/
void init(void)
/*
 PURPOSE: Used to initializes our OpenGL window        
 RECEIVES: Nothing
 RETURNS:  Nothing
 REMARKS:  Nothing  
 */
{
	glClearColor(1.0, 1.0, 1.0, 0.0);
}


/*-----------------------------------------------*/
void drawBezier(void)
/*
 PURPOSE: GLUT display callback function for this program.
 Demo point drawing a Bezier curve 
 RECEIVES: nothing
 RETURNS: nothing
 REMARKS:    
 */
{

	GLint nCtrlPts = 4;
	GLint nBezCurvePts = 1000;
	Point2D bezierPoint;
	Point2D ctrlPts[4] = {{-40.0, -40.0}, {-10.0, 200.0}, {10.0, -200.0}, {40.0, 40.0}};
	GLfloat u;
	GLint *C, k;
	
	C= new GLint[nCtrlPts];
	binomialCoefficients(nCtrlPts - 1, C);
	
	glClear(GL_COLOR_BUFFER_BIT);
	
	glColor3f(1.0, 0.0, 0.0);
	
	//here's where we draw the strings to the screen

	for (k =0; k < nBezCurvePts; k++) 
	{
		u = ((GLfloat) k)/ ((GLfloat) nBezCurvePts);
		cout << "u = " << u << "\n";
		computeBezierCurvePoint( u, &bezierPoint, nCtrlPts, ctrlPts, C);
		cout << "  pt.x" << bezierPoint.x << " pt.y" << bezierPoint.y << "\n";
		plotPoint(bezierPoint);
	}
	
	delete [] C;
	glFlush();
}


/*-----------------------------------------------*/
void winReshapeFn(int newWidth, int newHeight)
/*
 PURPOSE: Resizes/redisplays the contents of the current window
 RECEIVES: newWidth, newHeight -- the new dimensions (ignored)
 RETURNS: nothing
 REMARKS:    
 */
{	
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluOrtho2D(-50, 50, -50, 50);
	
	glClear(GL_COLOR_BUFFER_BIT);
}

int main(int argc, char** argv)
{
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
	glutInitWindowPosition(50, 50);
	glutInitWindowSize(500, 500);
	glutCreateWindow("An Example OpenGL Program");
	
	init();
	glutDisplayFunc(drawBezier);
	glutReshapeFunc(winReshapeFn);
	glutMainLoop();
	return 0;
}

OpenGL Example Running

Remarks

• This code shows you roughly the level of documentation I expect from homeworks and it also gives you an example of what code conforming to the departmental C++ guidelines looks like.
• I wrote this program on a Mac and compiled it after adding the frameworks indicated in the comments at the start of the file.
• A nice tutorial for setting up a project in Visual Studio can be found at:
  http://csf11.acs.uwosh.edu/cs371/visualstudio/.
• This code plots the Bezier curve as a sequence of points.
• We could use glBegin(GL_LINE_STRIP); ... glEnd(); or glBegin(GL_LINES); ... glEnd(); and between these list the glVertex* commands for the points we want to connect.
• We will see later some technique more geared toward drawing Bezier curves in OpenGL.

Quiz

Which of the following statements is true?

1. All control points of a Bezier curve lie on the curve.
2. The sum of all the blending functions for a Bezier curve totals to 1.
3. De Casteljau's Method cannot be used to find all of the points on a Bezier curve where u is between 0 and 1.

Hermite Polynomials

• Hermite polynomials give an alternative way to Bezier curves for representing cubic polynomials.
• They allow us to define such a curve by giving its endpoints and its derivatives at these endpoints.
• Rather than using the blending functions `B_i(u)` we instead choose functions `H_i(u)` which satisfy:

  `H_0(0) = 1`	`H_1(0) = 0`	`H_2(0) = 0`	`H_3(0) = 0`
  `H_0'(0) = 0`	`H_1'(0) = 1`	`H_2'(0) = 0`	`H_3'(0) = 0`
  `H_0(1) = 0`	`H_1(1) = 0`	`H_2(1) = 0`	`H_3(1) = 1`
  `H_0'(1) = 0`	`H_1'(1) = 0`	`H_2'(1) = 1`	`H_3'(1) = 0`

More on Hermite Polynomials

• Notice that if we need a degree three polynomial `\vec f(u)` that has value `\vec a ` at `u = 0` and `\vec d` at `u = 1` and has first derivative `\vec b` at `u = 0` and `\vec c` at `u = 1`, then we can define it in terms of our Hermite polynomials as:
  `\vec f(u) = \vec a H_0(u) + \vec b H_1(u) + \vec c H_2(u) + \vec d H_3(u)`.
• The four conditions of the last slide we gave for each `H_i` uniquely determine the degree three Hermite Polynomials.
• A little algebra and calculus show they are:
  `H_0(u) = (1 + 2u)(1 - u)^2 = 2u^3 - 3u^2 + 1`
  `H_1(u) = u(1 - u)^2 = u^3 - 2u^2 + u`
  `H_2(u) = -u^2(1 - u) = u^3 - u^2`
  `H_3(u) = u^2(3 - 2u)= -2u^3 + 3u^2`
  
• To convert from a Bezier curve `\vec q(u)` given by `\vec p_0`, `\vec p_1`, `\vec p_2`, `\vec p_3` to a Hermite representation we note that last day we already calculated the derivatives at the endpoints of a Bezier curve in terms of the `p_i`. So we have:
  `\vec q(u) = \vec p_0 H_0(u) + 3(\vec p_1 - \vec p_0)H_1(u) + 3(\vec p_3 - \vec p_2)H_2(u) + \vec p_3 H_3(u)`.
• For the other direction, given a curve in Hermite representation:
  `\vec f(u) = \vec r_0 H_0(u) + \vec r_1 H_1(u) + \vec r_2 H_2(u) + \vec r_3 H_3(u)`
  just set `\vec p_0 =\vec r_0`, `\vec p_3 = \vec r_3`, `\vec p_1 = \vec p_0 + 1/3 \vec r_1` `\vec p_2 = \vec p_3 + 1/3 \vec r_2` to get the corresponding Bezier control points.

Bezier Curves of General Degree

• We now look at Bezier Curves of arbitrary degree.
• To do this for degree `k`, we first generalize our blending functions (which we now call Bernstein polynomials) as follows:
  `B_i^k(u) = ((k),(i))u^i(1-u)^(k-i).`
• Notice when `k=3` these are just the blending functions we had before.
• Using the Bernstein polynomials we say for `k \geq 1`, the degree `k` Bezier curve `\vec q(u)` defined by the `k+1` control points `\vec p_0, \vec p_1, \ldots, \vec p_k` is the curve defined by:
  `\vec q(u) = \sum_(i=0)^kB_i^k(u)\vec p_i`,
  on the domain `u \in [0, 1]`.

More Bézier Curves of General Degree

• As with the degree three case, by examining the definition of the `B_i^k(u)`'s as well as using the binomial theorem, we can establish the following properties of the Bernstein polynomials for `k\geq 1:`
  
  1. `B_0^k(0) = 1 = B_k^k(1)`
  2. `\sum_(i=0)^kB_i^k(u) = 1`
  3. `B_i^k(u) \geq 0` for all `0 \leq u \leq 1`
• Hence, given our definition of `\vec q(u)` we have `\vec q(0) = \vec p_0` and `\vec q(1) = \vec p_k`.
• We also have from (2) and (3) above that `\vec q(u)` is a weighted average of its control points.
• The book works out the following equation for the derivative of `\vec q'(u)`:
  `\vec q'(u) = k \cdot \sum_(i=0)^(k-1)B_i^(k-1)(u)(\vec p_(i+1) - \vec p_i)` from which it follows that `\vec q'(0) = k(\vec p_1 - \vec p_0)` and `\vec q'(1) = k(\vec p_k - \vec p_(k-1))`

Properties of Bezier Curves of General Degree

• As with the degree three case, we have that a Bezier curve of general degree is contained within the convex hull of its control points.
• Another property of Bezier curves is invariance under affine transformations. Let `A` be affine, that is `A(\vec x) = B(\vec x) + \vec u` for some fixed `\vec u` and for some `B` linear. Then `A(\vec q(u))` is the same curve as that obtained by the control points `A(\vec p_i)`.
• Bezier curves enjoy as well the variation diminishing property. Define the control polygon to be the series of straight line segments connecting the control points `p_0, p_1, \ldots, p_k` in sequential order. The variation diminishing property says that, for any `L` in `\mathbb R^2` the number of times `\vec q(u)` crosses the line is less than or equal to the number of times the control polygon crosses the line.
• As with the degree three case, sometimes it is useful to join together two degree `k` Bezier curves.
• Let `\vec p_(1,i)`, `\vec p_(2,i)` be the control points of these two curves. To join the curves we want `\vec p_(1,k) = \vec p_(2,0)`. For the join to be `C^1`-continuous, we need `p_(1,k) - p_(1,k-1)` equal to `p_(2,1) - p_(2,0)`. For `G^1`-continuity they only have to be proportional to each other.