OpenGL and Parametric Curves Advanced Multimedia Technology: Computer Graphics Yung-Yu Chuang 2005/12/21 with slides by Brian Curless, Zoran Popovic, Robin Chen and Doug James

Review of graphics pipeline Transformation

Review of graphics pipeline Projection & clipping

Review of graphics pipeline Rasterization Visibility

Review of graphics pipeline Shading

Hierarchical modeling: a robot arm

First implementation

Better implementation

OpenGL implementation

Hierarchical modeling

Implementation

Human with hands

Better implementation

OpenGL implementation

OpenGL A low-level OS-independent graphics API for 2D and 3D interactive graphics. Initiated by SGI (called GL at early time) Implementation, for Windows, hardware vendors provide suitable drivers for their own products; for Linux, we have Mesa.

Helper libraries OpenGL does not provide OS-dependent functions such as windowing and input –GL: core graphics functions –GLU: graphics utilities in top of GL –GLUT: input and windowing functions

How does it work? From the programmer’s view –Specify geometric properties of the objects –Describe material properties –Define viewing –Define camera and object transformations OpenGL is a state machine –States: color, material properties, line width, current viewing –States are applied to subsequent drawing commands –Input: description of geometric objects –Output: shaded pixels

How does it work From the implementer’s perspective Graphics pipeline Primitives + material properties Rotate Translate Scale Is it Visible? 3D to 2DScan conversion Visibility determination Display

Primitives: drawing a polygon // put GL into polygon drawing mode glBegin(GL_POLYGON); // define vertices glVertex2f(x0, y0); glVertex2f(x1, y1); glVertex2f(x2, y2); glEnd(); Code available at

Primitives Hardware may be more efficient on triangles; stripes require less data

Polygon restrictions In OpenGL, polygons must be simple and convex not simple not convex

Attributes Part of the state of the graphics pipeline Set before primitives are drawn. Remain in effect! Example: –Color, including transparency –Reflection properties –Shading properties

Primitives: material properties glColor3f(r,g,b); All subsequent primitives will use this color. Colors are not attached to objects. The above command only changes the system states. OpenGL uses red, green and blue color model. Each components are ranged within 0 and 1.

Primitives: material properties

Simple transformations Rotate by a given angle (in degrees) about ray from origin through (x,y,z) glRotate{fd}(angle, x, y, z); Translate by a given x, y, z values glTranslate{fd}(x, y, z); Scale with a factor in the x, y, and z directions glScale{fd}(x, y, z); glPushMatrix(); glPopMatrix();

Orthographic projection glOrtho(left, right, bottom, top, near, far);

Camera transformations gluLookAt(eyex, eyey, eyez, cx, cy, cz, upx, upy, upz);

Example: drawing a box

Example: drawing a shaded polygon

Initializing attributes

Callback functions Handle “events”, Idle, Keyboard, Mouse, Menu, Motion, Reshape The display callback is installed by glutDisplayFunc()

Actual drawing function

Results glShadeModel(GL_FLAT) glShadeModel(GL_SMOOTH)

Depth buffer in OpenGL glutInitDisplayMode(GLUT_DEPTH); glEnable(GL_DEPTH_TEST); glClear(GL_DEPTH_BUFFER_BIT);

Double buffering Flicker if drawing overlaps screen refresh Solution: use two frame buffers –Draw into one buffer –Swap and display, while drawing other buffer glutInitDisplayMode(GLUT_SINGLE) glutInitDisplayMode(GLUT_DOUBLE) glutSwapBuffers()

Example: rotate a color cube Step 1: define the vertices

Example: rotate a color cube Step 2: enable depth testing and double buffering

Example: rotate a color cube Step 3: create window and set callbacks

Example: rotate a color cube Step 4: reshape callback, enclose cube, preserve aspect ratio

Example: rotate a color cube Step 5: display callback, clear, rotate, draw, flush, swap

Example: rotate a color cube Step 6: draw cube by drawing faces, orientation consistency

Example: rotate a color cube Step 7: drawing face

Example: rotate a color cube Step 8: animation, set idle callback spinCube()

Example: rotate a color cube Step 9: change axis of rotation using mouse callback

Example: rotate a color cube Step 10: toggle rotation or exit using keyboard callback

Mathematical curve representation

Parametric polynomial curves

Cubic curves N too small → less flexibility in controlling the shape of the curve N too large → often introduce unwanted wiggles

Compact representation

Constrain the cubics Hermite: defined by two endpoints and two endpoint tangent vectors Bezier: defined by two endpoints and two other points that control the endpoint tangent vectors Spline: defined by four control points

Hermite curves

Computing Hermite basis matrix

Computing a point

Blending functions

Bezier curves

Bezier basis matrix

Bezier blending function

Alternative (de Casteljau’s algorithm)

Finding Q(u)

Bezier curve each is between 0 and 1 sum of all four is exactly 1 Curve lies within the convex Hull of its control points

Displaying Bezier curves

Testing for flatness

What do we want for a curve? Local control Interpolation Continuity

Local control One problem with Bezier curve is that every control points affect every point on the curve (except for endpoints). Moving a single control point affects the whole curve. We’d like to have local control, that is, have each control point affect some well- defined neighborhood around that point.

Interpolation Bezier curves are approximating. The curve does not necessarily pass through all the control points. We’d like to have a curve that is interpolating, that is, that always passes through every control points.

Continuity We want our curve to have continuity: there shouldn’t be any abrupt changes as we move along the curve.

Splines We will splice together a curve from individual Bezier segments. We call these curves splines. When splicing Bezier together, we need to worry about continuity.

Ensuring C 0 continuity

1 st derivatives at the endpoints

Ensuring C 1 continuity

The C 1 Bezier spline

Catmull-Rom splines

Catmull-Rom basis matrix

2 nd derivatives at the endpoints

Ensuring C 2 continuity

A-frames and continuity

B-spline