## Homework 8, due Thursday, Nov 18.

Splines:

In class I talked about parametric cubic splines, and briefly mentioned parametric bicubic surface patches. For this assignment I would like you to implement an interactive Java applet that shows its user some cool picture made out of spline curves, and allows the user to drag around control points to modify that picture.

For this assignment you'll want to go back to using the `java.awt.graphics` class that you used earlier in the semester, since you'll mostly be drawing lines and circles - you will be making curves by drawing lots of little successive lines end to end.

Your program should behave as follows:

• Create a picture of something cool out of Bezier curves. You might want to create an interesting cartoon character, or some sort of fancy letter shape, or perhaps something political or a hopeful early Thankgiving theme. Remember that you can also use different colors to make things more interesting. If you're feeling a little ambitious, you can try to create filled-in shapes by using the `fillPolygon` method, rather than just draw curves via the `drawLine` method.

• Remember that every third control point in curve specified with Bezier splines (ie: control points P0, P3, P6, etc), is an interpolating control point that acts as the first and last control point for an individual Bezier spline.

• When the user drags on a control point (ie: does a mouseDown event very close to that control point, followed by a sequence of mouseDrag events), the applet should move that control point, so that it follows the cursor position.

• You might want to explicitly have an "edit" mode, in which you show a faint line between successive control points (perhaps in a gray or pink or light blue color), and mark the interpolating control points P0, P3, P6, etc, with large dots (using the `fillOval` method) to show that those control points are the ones which mark the beginning and end of the individual Bezier cubic spline curves.

An important thing to keep in mind is that if you want two successive Bezier curves that share some key point P3n to join together without a sharp bend between them, then you must make sure that the slope from P3n to the next key point P3n+1 is equal to the slope from the previous key point P3n-1 to P3n. In order to constrain the key points so that successive spline segments maintain the same slope at their common point when the user drags control points around, you should do something like the following:

• When you first create that second spline, make sure that you place P3n+1 in a line with P3n-1 and P3n (the last two points of the previous curve).

• When the user moves some interpolating key point P3n, you should move the two key points before and after it ( P3n-1 and P3n+1 by the same amount.

• When the user moves one of the non-interpolating key points, then you should move the key point on the other side of the nearest interpolating key point so that the three successive key points P3n-1, P3n, P3n+1 remain co-linear.

• To draw the actual curve, plot the individual Bezier curves defined by key points (P0,P1,P2,P3), (P3,P4,P5,P6), etc., as described below.

As we covered in class, the way you define a Bezier curve from four control points A,B,C,D is to treat the set of x coordinates {Ax, Bx, Cx, Dx} and the set of y coordinates {Ay, By, Cy, Dy} independently.

For every type of spline there is a unique matrix that transforms the control point values to the (a,b,c,d) values of the cubic polynomial at3+bt2+ct+d.

As we showed in class, for Bezier curves this transformation matrix is:

 -1 3 -3 1 3 -6 3 0 -3 3 0 0 1 0 0 0

To get the cubic polynomial equation for the x coordinates and y coordinates, respectively, you need to use this matrix to transform the two geometry column vectors:

 Ax Bx Cx Dx Ay By Cy Dy
into the two column vectors of cubic coefficients:
 ax bx cx dx ay by cy dy

which will let you evaluate the cubic polynomials:

X(t) = axt3 + bxt2 + cxt + dx
Y(t) = ayt3 + byt2 + cyt + dy

Once you know the cubic polynomials that define X(t) and Y(t) for any individual Bezier curve, the simplest way to draw the curve is to loop through values of t, stepping from 0.0 to 1.0, and draw short lines between successive values. For example, if you have already defined methods `double X(double t)` and `double Y(double t)`, then you can use code structured something like:

```   for (double t = 0 ; t <= 1 ; t += ε)
g.drawLine((int)X(t), (int)Y(t), (int)X(t+ε), (int)Y(t+ε));
```