Create smooth curve with interpolation (Vecmath) ?

Engines, Libraries and Tools Java 3D
#1

I use the Vecmath method: Tuple3d.interpolate(Tuple3d t1, Tuple3d t2, double alpha)
… to interpolate between some tuples. It’s a linear interpolation.
What I’d like to have however is some kind of curve interpolation, like Sinus/Cosinus, Bezier, etc.

How to achieve this, please?

For example, this little table contains a value followed by the time key. Ignoring the Z axis:

x-axis: value, time

1 0
2 1
3 3
6 6
8 10
9 11

y-axis: value, time

1 0
4 1
5 3
1 6
3 10
2 11

The result should look like this (it’s a Lightwave animation curve) :

PS: Maybe Java3d’s behaviour does do this, I don’t know… however I’m not using Java3d, just Jogl plus Vecmath (the free Japanese version).

#2

There’s even one more value per time key: rotation. So it’s actually:
, ,

All of them I’d like to interpolate so that I can move smoothly with small time steps.

I’m also scanning some math and 3d graphics sites for such thing (which is quite common in 3d I guess) but I asked here because maybe there’s some direct way to use Vecmath or some other Java libs (Java2d?).

#3

To draw a (cubic) bezier curve you’ll need at least four control points, since each section will make use of four of them to approximate the curve. (EDIT: bad sentence)

In the following code, we’re inside a loop calculating each curvepoint based on the controlpoints. First controlpoint is p_start, and the last is p_start+3. The variable l_t is the interpolator from the bezier curve section start and the bezier curve section end. The interpolator must be increased by the delta distance per curvesegment, which will be 1/sectionsegments.

The next bezier section (not to be confused with a curve-section here) will start at p_start+3 and end at p_start+6, four points. (EDIT: I wrote +7…)

To understand the bezier equation completely, you should make a google search on it.


m_curvepoints[l_curpoint].x = (int)(m_controlpoints[p_start+0].x*(1-l_t)*(1-l_t)*(1-l_t)
                                    + m_controlpoints[p_start+1].x*3.0*l_t*(1-l_t)*(1-l_t)
                                    + m_controlpoints[p_start+2].x*3.0*l_t*l_t*(1-l_t)
                                    + m_controlpoints[p_start+3].x*l_t*l_t*l_t);
                        m_curvepoints[l_curpoint].y = (int)(m_controlpoints[p_start+0].y*(1-l_t)*(1-l_t)*(1-l_t)
                                    + m_controlpoints[p_start+1].y*3.0*l_t*(1-l_t)*(1-l_t)
                                    + m_controlpoints[p_start+2].y*3.0*l_t*l_t*(1-l_t)
                                    + m_controlpoints[p_start+3].y*l_t*l_t*l_t);

If this doesn’t help, or doesn’t make any sense, I can upload the entire source so you can read through it yourself :slight_smile:

Was this even close to what you were thinking of?

-Trond

#4

[quote]Was this even close to what you were thinking of?
[/quote]
Yes, thanks, this is a good start.
On the Bezier topic I found http://mathworld.wolfram.com/BezierCurve.html which I’ll have to read (plus some of its links like NURBS curve etc).

Skol. :wink: