Math
155B – Topics in Computer Graphics – Spring 2019
Project #1 -
Catmull-Rom, Overhauser, and Centripetal interpolating splines
Overview: For this assignment, you will write a program that accepts
points via mouse clicks, and draws a spline curve that interpolates them.
Your program will generate three kinds of curves: Catmull-Rom curves and Overhauser
curves with chord length parameterization and with centripetal
parameterization..
Due date: Friday, April 12, 9:00pm.
Download a sample executable from:
http://www.math.ucsd.edu/~sbuss/CourseWeb/Math155B_2019Spring/Project_1/ConnectDotsDemo_Spring2019.zip
Download starter code from ConnectDotsModern program on the book’s
software web page. The direct URL is:
http://www.math.ucsd.edu/~sbuss/MathCG2/OpenGLsoft/ConnectDotsModern
Your program should support the following: (Test them out with the
executable downloaded in the zip file above).
- Left mouse button is used to
place points in the window. The curve is updated on the screen
interactively with mouse clicks.
- The curve interpolates all the
points, including the first and last points. This was not true
of the Catmull-Rom and Overhauser splines as defined in class. You
may implement this in several ways. The most likely ways are either: (a) by
acting as if the first and last point are placed twice or (b) by setting
the first derivative to zero at the beginning and the end of the curve.
(The “Demo” program uses the first option, but the second option is
perhaps better. Either way is OK for your programming assignment.)
- The 0 command
shows straight-line interpolation;
- The 1 command
selects Catmull Rom curves (unit length parameterization);
- The 2 command selects
Overhauser curves with chord length parameterization;
- The 3 command selects
Overhauser curves with centripetal parameterization.
- The f (F)
command removes the first point on the curve. The l (L) command
removes the last point on the curve ("f" for "first"
and "l" for "last"). If more than 100 points are
placed, then the first point is removed when a new point is added to the
end. This is already implemented in the ConnectDotsModern program.
- (Optional.) The command c (C)
(for “control polygon”) toggles drawing of the control polygon. This is
not a required element of the programming assignment, but it is
recommended to implement it to help with debugging.
- Selecting a point by right
clicking with the mouse, and holding the mouse button down, allows you to
drag an interpolation point to a new position. This is already implemented
in the supplied ConnectDotsModern software: your program only needs to
update the interpolating curve when this happens.
- BONUS TASK: If you find all of
the above is implemented easily, this is a bonus feature: Design and
implement a method to add interpolation points in the middle of the curve.
For instance, by shift-right-clicking on the curve. (This is worth up to
1 point (out of a total of 20) for your programming assignment score.)
A starter version of the program is available online from http://math.ucsd.edu/~sbuss/MathCG2/OpenGLsoft/ConnectDotsModern. This
program supports catching mouse clicks, straightline interpolation, the f and l commands,
clamping to at most 100 points, and dragging vertices. It draws only
straight-line segments, not curves: your main job is to add to the
program the ability to draw interpolating curves (Catmull-Rom and two kinds of Overhauser
splines).
The sample program draws big, black points and thick,
colored lines and curves.
Helpful hints:
- Start with the provided ConnectDotsModern
code.
- For each segment of the curve,
compute the Bezier curve control points for that segment. This will give
you a total of 3*(NumDots-1)+1 many points. Store these in a separate
array. If your program also displays the control polygons of all the
Bezier sub-curves, you will need to also store these is a separate
VAO/VBO.
- Step 2 is performed differently for Catmull Rom, chord-length Overhauser
and centripetal Overhauser, since they calculate the control points for
the Bezier subcurves differently, but the rest of the steps can be the
same for all three types of curves.
- Then, for each Bezier subcurve
of the curve, calculate sufficiently many points on the curve, store them
into an array, and then load them into a VBO. You should use the
DeCasteljau algorithm to evaluate the curves.
You are recommended to use a separate VAO and VBO for drawing the curve as
a sequence of short line segments. Introduce a parameter (suggestion:
call it “MeshRes”) for the number of straight-line segments used to
approximate each Bezier curve; experiment to find out what values work
well (say between 20 and 40).
- Since there is a known upper
bound on the number of interpolation points, you can preallocate arrays to
hold all your data: you do not need to dynamically allocate arrays.
- Your points are points in
2-space. You can either store them as a arrays with separate x- and y-
coordinates. But it is likely to be better use the VectorR2 class
(available from the textbook’s course web page in LinearMapR2.h) to handle
2-vectors directly. (Alternately, find another 2-vector C++ class to use,
or write your own…)
- Watch out for repeated points
(obtained by clicking the same point twice in a row), so you do not get a
divide-by-zero exception. Handle repeated points as you think best.
Be prepared to explain how you handled this.
Hand in procedure: FIRST: As usual, make sure your code
compiles and runs under Visual Studio on the computer lab systems. In-person
grading will use these systems. Please do not modify your files after the due
date without letting us know first.
SECOND: Upload your primary source file(s) to gradescope.
Grading: Grading is an individual session with Nick Sieger or
Professor Buss. You should be prepared to explain how your program
works, and to show examples of the relative advantages and disadvantages of the
Catmull-Rom splines and the two types of Overhauser splines.