Outline

• Joining and Subdividing Bezier Patches
• Quiz
• OpenGL and Bezier Curves
• Rational Bezier Curves

Joining Bezier Patches

• Recall last Thursday, we had just introduced degree three Bezier Patches and given the equations for their first derivative at their control points.
• We now want to consider gluing multiple such patches together to specify a smooth surface.
• Suppose we have two Bezier Patches `\vec q_1(u,v)` and `\vec q_2(u,v)` with control points `\vec p_(i,j)` and `\vec r_(i,j)` respectively.
• We will let `\vec q_2(u,v)` have the domain `[0,1]\times[0,1]` and translate `\vec q_1(u,v)`'s domain so that it is `[-1,0]\times[0,1]`.
• To make the right boundary of `\vec q_1` match with the left boundary of `\vec q_2` we need to ensure that the control points along these boundaries match up. This requires: `\vec p_(3,j) = \vec r_(0,j)` for `j = 0, 1, 2, 3`.
• Suppose we now have continuous boundaries and want the partial derivatives at the boundaries to be continuous.
• So we are interested in continuity in the `u` direction which will be across the boundary as the `v` direction is handle by the two curves lining up on the boundary.
• It turns out for `C^1`-continuity that it is sufficient that `\vec p_(3,j) - \vec p_(2,j) = \vec r_(1,j) - \vec r_(0,j)` where `j = 0, 1, 2, 3`. For `G^1`-continuity you just need these differences are proportional.

Subdividing Bezier Patches

• As with Bezier curves you can use recursive subdivision to draw Bezier patches
• The idea is to recursively split a given patch into smaller patches until each patch is essentially a flat quadrilateral and then draw this using two triangles.
• There is now one new difficulty: since some patches may need to be subdivided further than others, it can happen that a surface is subdivided and its neighbor is not.
• This can result in a problem called "cracking" illustrated by the diagram above.
• One fix is to replace the common boundary of the two patches with a straight line. However, this can cause problems with shading because the surface normals along the common boundary should also line up.
• Another way to fix this is to subdivide `q_2` further so that the common boundary has the same points and normals with respect to both patches.

Quiz

Which of the following statements is true?

1. A line intersects a general Bezier curve at most the same number of times it intersects its control polygon.
2. A Hermite representation makes use of four control points.
3. A typical degree three Bezier patch can be specified with eight control points.

OpenGL and Bezier Curves and Patches

• The built-in Bezier functions in OpenGL can only be used for drawing not animating.
• In the 1-D case the basic idea to use these functions is to create your own array with the control points of your curve.
• Then you use the glMap1*(GL_MAP1_VERTEX_3, ...) function to tell OpenGL that these points will be used to draw a Bezier curve and how it also tell OpenGL about how it is parameterized.
• Next to enable OpenGL to use the set-up curve you have a command like: glEnable(GL_MAP1_VERTEX_3);
• Finally, whenever you want to get the coordinates of `u` along the curve, you call the function: glEvalCoord1*(u);
• As usual, by '*' in the above I mean either f, or i, or iv, fv (for arrays).
• The process of drawing a Bezier curve is illustrated by the code on the next slide.

OpenGL Bezier Curve Example

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

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

#ifdef __APPLE__ //for MAC
/*
 I created my project under xcode. I chose new C++ tool as the kind of project.
 Then under External frameworks and libraries 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;


/*-----------------------------------------------*/
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.
 Drawing a Bezier curve with glMap1* functions 
 RECEIVES: nothing
 RETURNS: nothing
 REMARKS: 
 */
{
	
	GLfloat ctrlPts[4][3] = {{-40.0, -40.0, 0.0}, 
        {-10.0, 200.0, 0.0}, {10.0, -200.0, 0.0}, 
		{40.0, 40.0, 0.0}};

	glMap1f (GL_MAP1_VERTEX_3, 
                  0.0 /* uMin*/, 1.0 /* uMax*/, 3 /* stride*/, 4 /*num points */,
	          *ctrlPts);
	glEnable(GL_MAP1_VERTEX_3);
	
	GLint k;
	
	// draw curve in blue
	glColor3f(0.0, 0.0, 1.0);
	
	glBegin(GL_LINE_STRIP);
	   for (k = 0; k <= 50; k++) {
		   glEvalCoord1f(GLfloat(k)/50.0);
	   }
	glEnd();
	
	// draw control points in red
	glColor3f(1.0, 0.0, 0.0);
	glPointSize( 5.0 );
	
	glBegin(GL_POINTS);
	for (k = 0; k < 4; k++) {
		glVertex3fv(&ctrlPts[k][0]);
	}
	glEnd();
	
	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(-300, 300, -300, 300);
	
	glClear(GL_COLOR_BUFFER_BIT);
}

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

Example Screenshot

Remarks

• OpenGL provides a functions glMapGrid1*(n, u1, u2) and glEvalMesh1(mode, n1, n2), to generate uniform spaced points along the curve.
• In particular, we could have replaced the for loop of the last example with:

  glMapGrid1f(50, 0.0, 1.0);
  glEvalMesh1(GL_LINE, 0, 50);
  

• For Bézier patches, we use the functions glMap2*(GL_MAP_VERTEX_3, uMin, uMax, uStride, nuPts, vMin, vMax, vStride, nvPts, *ctrlPts); to tell OpenGL about a Bezier patch.
• Then we call glEnable(GL_MAP2_VERTEX_3); to get it render to calculate points on it. We call glDisable(GL_MAP2_VERTEX_3); later if we want to shut this off.
• To evaluate points on the surface we can call glEvalCoord2*(uValue, vValue);
• Alternatively, we could also used: glMapGrid2*(nu, u1, u2, nv, v1, v2); and glEvalMesh2(mode, nu1, nu2, nv1, nv2);

Bézier Patch Code

/******************************************************
 * Project:         CS216 Bezier Patch 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<windows.h> //for windows
#include <GL/glut.h>
#include <GL/glu.h>
#endif

#ifdef __APPLE__ //for MAC
/*
 I created my project under xcode. I chose new C++ tool as the kind of project.
 Then under External frameworks and libraries 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;

/*
 CONSTANTS
 */

//Camera constants
const GLfloat CAMERA_X = -5.0; //camera's position (looks at origin)
const GLfloat CAMERA_Y = -3.0;
const GLfloat CAMERA_Z = 10.0;
const GLfloat UP_X = 0.0; //camera's up vector
const GLfloat UP_Y = 1.0;
const GLfloat UP_Z = 0.0;

//View Volume
const GLfloat NEAR_CLIP = 2.0;
const GLfloat FAR_CLIP = 100;

/*
 GLOBALS
 */
GLsizei winWidth = 500, winHeight = 500; // used for size of window
GLsizei initX = 50, initY = 50; // used for initial position of window


/*-----------------------------------------------*/
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.
 Drawing a Bezier curve with glMap1* functions 
 RECEIVES: nothing
 RETURNS: nothing
 REMARKS:   
 */
{
	
	GLfloat ctrlPts[4][4][3] = {
	  {{-1.5, -1.5, 4.0}, {-.5, -1.5, 2.0}, 
		  {-.5, -1.5, -1.0}, {1.5, -1.5, 2.0} }, 
	  {{-1.5, -.5, 1.0}, {-.5, -.5, 3.0}, 
		  {.5, -.5, 0.0}, {1.5, -.5, 1.0} }, 
	  {{-1.5, .5, 4.0}, {-.5, .5, 0.0}, 
		  {.5, .5, 3.0}, {1.5, .5, 4.0} }, 
	  {{-1.5, 1.5, -2.0}, {-.5, 1.5, -2.0}, 
		  {.5, 1.5, 0.0}, {1.5, 1.5, -1.0} } 

	};
	
	glMap2f (GL_MAP2_VERTEX_3, 0.0 /* uMin*/, 1.0 /* uMax*/, 3 /* u stride*/, 4 /*num points u*/,
			0.0 /* vMin*/, 1.0 /* vMax*/, 12 /*v stride*/, 4, &ctrlPts[0][0][0]);
	glEnable(GL_MAP2_VERTEX_3);
	
	GLint k, j;

	//draw patch in read
	glColor3f(1.0, 0.0, 0.0);
	glMapGrid2f(50, 0.0, 1.0, 50, 0.0, 1.0);
	glEvalMesh2(GL_FILL, 0, 50, 0, 50);
	
	// draw curves on patch in blue
	glColor3f(0.0, 0.0, 1.0);
	
    for (k = 0 ; k <= 8; k++) {
		glBegin(GL_LINE_STRIP);
		for (j = 0; j <= 40; j++) {
			glEvalCoord2f(GLfloat(j)/40.0, GLfloat(k)/8.0);
		}
		glEnd();
		
		glBegin(GL_LINE_STRIP);
		for (j = 0; j <= 40; j++) {
			glEvalCoord2f(GLfloat(k)/8.0, GLfloat(j)/40.0);
		}
		glEnd();
		
	}


	
	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:    
 */
{	
	glViewport(0, 0, newWidth, newHeight);
	
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	glFrustum(-1.0, 1.0, -1.0, 1.0, NEAR_CLIP, FAR_CLIP);

    gluLookAt(CAMERA_X, CAMERA_Y, CAMERA_Z, 0.0, 0.0, 0.0, UP_X, UP_Y, UP_Z);
	
	glClear(GL_COLOR_BUFFER_BIT);

	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();

	
}

int main(int argc, char** argv)
{
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
	glutInitWindowPosition(initX, initY);
	glutInitWindowSize(winWidth, winHeight);
	glutCreateWindow("An Example Bezier Patch");
	
	init();
	glutDisplayFunc(drawBezier);
	glutReshapeFunc(winReshapeFn);
	glutMainLoop();
	return 0;
}

Example Screenshot

Rational Bezier Curves

• A Bezier curve is called rational if its control points are specified with homogeneous coordinates.
• That is, in `\mathbb R^3` each control point is specified as a 4-tuple `\vec p_i = \langle x, y, z, w\rangle`.
• The curve is still defined as a weighted average of its control points:
  `\vec q(u) = \sum_iB_i^k(u)\vec p_i`.
• There are several advantages to using homogeneous coordinates: (a) the w-coordinate can serve as a weight factor that can be used to increase of decrease the relative weight of a control point. (b) The use of weights allows rational Bezier curves to define circular arcs, ellipses, hyperbolas, and other conic curves. (c) Rational Bezier curve are preserved under perspective transformations, not just affine transformations. (d) Control points can be placed at infinity.

More on Rational Bezier Curves

Let's look at (a) of the last slide in more detail...

• A point `\vec p` in 3D is represented in homogeneous coordinates using the notation `\langle w\vec p, w \rangle` for nonzero `w`.
• So a point on `\vec q(u)` is defined by the weighted average of its control points:
  `\vec q(u) = \sum_iB_i^k(u)\langle w_i\vec p_i, w_i \rangle`.
• This corresponds in `\mathbb R^3` to the point (using linearity)
  `\vec q(u) = \sum_i \frac{w_iB_i^k(u)}{\sum_jw_jB_j^k(u)}p_i`.

Rational Bezier Curves and Points at Infinity

Let's look at (d) of a couple slides back in more detail...

• Let `\vec p_0 = \langle 0, 1, 1 \rangle`, `\vec p_1 = \langle 1, 0, 0 \rangle`, and `\vec p_2 = \langle 0, -1, 1 \rangle` be homogeneous representations of points in `\mathbb R^2`. Let `\vec q(u)` be the degree two Bezier curve given by these points. Then `\vec q(u)` traces out the right half of the circle `x^2 + y^2 = 1` as `u` varies from 0 to 1.
• We'll prove this next day.