Previous:Lathe Object   Main Index   Next:Mesh Object

#### Understanding The Concept of Splines

It would be helpful, in order to understand splines, if we had a sort of Spline Workshop where we could practice manipulating types and points of splines and see what the effects were like. So let's make one! Now that we know how to create a basic lathe, it will be easy (see file `lathdem2.pov`):

```  #include "colors.inc"

camera {

orthographic

up <0, 5, 0>

right <5, 0, 0>

location <2.5, 2.5, -100>

look_at <2.5, 2.5, 0>

}

/* set the control points to be used */

#declare Red_Point    = <1.00, 0.00, 0>;

#declare Orange_Point = <1.75, 1.00, 0>;

#declare Yellow_Point = <2.50, 2.00, 0>;

#declare Green_Point  = <2.00, 3.00, 0>;

#declare Blue_Point   = <1.50, 4.00, 0>;

/* make the control points visible */

cylinder { Red_Point, Red_Point - 20*z, .1

pigment { Red }

finish { ambient 1 }

}

cylinder { Orange_Point, Orange_Point - 20*z, .1

pigment { Orange }

finish { ambient 1 }

}

cylinder { Yellow_Point, Yellow_Point - 20*z, .1

pigment { Yellow }

finish { ambient 1 }

}

cylinder { Green_Point, Green_Point - 20*z, .1

pigment { Green }

finish { ambient 1 }

}

cylinder { Blue_Point, Blue_Point- 20*z, .1

pigment { Blue }

finish { ambient 1 }

}

/* something to make the curve show up */

lathe {

linear_spline

5,

Red_Point,

Orange_Point,

Yellow_Point,

Green_Point,

Blue_Point

pigment { White }

finish { ambient 1 }

}```

A simple "Spline Workshop".

Now, we take a deep breath. We know that all looks a bit weird, but with some simple explanations, we can easily see what all this does.

First, we are using the orthographic camera. If we haven't read up on that yet, a quick summary is: it renders the scene flat, eliminating perspective distortion so that in a side view, the objects look like they were drawn on a piece of graph paper (like in the side view of a modeler or CAD package). There are several uses for this practical new type of camera, but here it is allowing us to see our lathe and cylinders edge on, so that what we see is almost like a cross section of the curve which makes the lathe, rather than the lathe itself. To further that effect, we eliminated shadowing with the `ambient 1` finish, which of course also eliminates the need for lighting. We have also positioned this particular side view so that <0,0> appears at the lower left of our scene.

Next, we declared a set of points. We note that we used 3D vectors for these points rather than the 2D vectors we expect in a lathe. That's the exception we mentioned earlier. When we declare a 3D point, then use it in a lathe, the lathe only uses the first two components of the vector, and whatever is in the third component is simply ignored. This is handy here, since it makes this example possible.

Next we do two things with the declared points. First we use them to place small diameter cylinders at the locations of the points with the circular caps facing the camera. Then we re-use those same vectors to determine the lathe. Since trying to declare a 2D vector can have some odd results, and isn't really what our cylinder declarations need anyway, we can take advantage of the lathe's tendency to ignore the third component by just setting the z-coordinate in these 3D vectors to zero.

The end result is: when we render this code, we see a white lathe against a black background showing us how the curve we've declared looks, and the circular ends of the cylinders show us where along the x-y-plane our control points are. In this case, it's very simple. The linear spline has been used so our curve is just straight lines zig-zagging between the points. We change the declarations of `Red_Point` and `Blue_Point` to read as follows (see file `lathdem3.pov`).

```  #declare Red_Point  = <2.00, 0.00, 0>;

#declare Blue_Point = <0.00, 4.00, 0>;```

Moving some points of the spline.

We re-render and, as we can see, all that happens is that the straight line segments just move to accommodate the new position of the red and blue points. Linear splines are so simple, we could manipulate them in our sleep, no?

Let's try something different. First, we change the points to the following (see file `lathdem4.pov`).

```  #declare Red_Point    = <1.00, 0.00, 0>;

#declare Orange_Point = <2.00, 1.00, 0>;

#declare Yellow_Point = <3.50, 2.00, 0>;

#declare Green_Point  = <2.00, 3.00, 0>;

#declare Blue_Point   = <1.50, 4.00, 0>;```

We then go down to the lathe declaration and change `linear_spline` to `quadratic_spline`. We re-render and what do we have? Well, there's a couple of things worthy of note this time. First, we will see that instead of straight lines we have smooth arcs connecting the points. These arcs are made from quadratic curves, so our lathe looks much more interesting this time. Also, `Red_Point` is no longer connected to the curve. What happened?

Well, while any two points can determine a straight line, it takes three to determine a quadratic curve. POV-Ray looks not only to the two points to be connected, but to the point immediately preceding them to determine the formula of the quadratic curve that will be used to connect them. The problem comes in at the beginning of the curve. Beyond the first point in the curve there is no previous point. So we need to declare one. Therefore, when using a quadratic spline, we must remember that the first point we specify is only there so that POV-Ray can determine what curve to connect the first two points with. It will not show up as part of the actual curve.

There's just one more thing about this lathe example. Even though our curve is now put together with smooth curving lines, the transitions between those lines is... well, kind of choppy, no? This curve looks like the lines between each individual point have been terribly mismatched. Depending on what we are trying to make, this could be acceptable, or, we might long for a more smoothly curving shape. Fortunately, if the latter is true, we have another option.

The quadratic spline takes longer to render than a linear spline. The math is more complex. Still longer needs the cubic spline, yet, for a really smoothed out shape, this is the only way to go. We go back into our example, and simply replace `quadratic_spline` with `cubic_spline` (see file `lathdem5.pov`). We render one more time, and take a look at what we have.

A cubic spline lathe.

While a quadratic spline takes three points to determine the curve, a cubic needs four. So, as we might expect, `Blue_Point` has now dropped out of the curve, just as `Red_Point` did, as the first and last points of our curve are now only control points for shaping the curves between the remaining points. But look at the transition from `Orange_Point` to `Yellow_Point` and then back to `Green_Point`. Now, rather than looking mismatched, our curve segments look like one smoothly joined curve.

The concept of splines is a handy and necessary one, which will be seen again in the prism and polygon objects. But with a little tinkering we can quickly get a feel for working with them.

Previous:Lathe Object   Main Index   Next:Mesh Object