Implementing Bezier Curves

I am trying to implement Bezier Curves for an assignment. I am trying to move a ball (using bezier curves) by giving my function an array of key frames. The function should give me all the frames in between the key frames ... or control points ... but although I'm using the formula found on wikipedia... it is not really working :s

her's my code:

  private void interpolate(){
      float x,y,b, t = 0;
      frames = new Frame[keyFrames.length];
      for(int i =0;i<keyFrames.length;++i){   
         t+=0.001;
         b = Bint(i,keyFrames.length,t);   
         x = b*keyFrames[i].x;
         y = b*keyFrames[i].y;
         frames[i] = new Frame(x,y);     
      }
  }

private float Bi开发者_运维知识库nt(int i, int n, float t){
  float Cni = fact(n)/(fact(i) * fact(n-i));
  return Cni * pow(1-t,n-i) * pow(t,i);
}

Also I've noticed that the frames[] array should be much bigger but I can't find any other text which is more programmer friendly

Thanks in advance.

There are lots of things that don't look quite right here.

1. Doing it this way, your interpolation will pass exactly through the first and last control points, but not through the others. Is that what you want?

2. If you have lots of key frames, you're using a very-high-degree polynomial for your interpolation. Polynomials of high degree are notoriously badly-behaved, you may get your position oscillating wildly in between the key frame positions. (This is one reason why the answer to question 1 should probably be no.)

3. Assuming for the sake of argument that you really do want to do this, your value of t should go from 0 at the start to 1 at the end. Do you happen to have exactly 1001 of these key frames? If not, you'll be doing the wrong thing.

4. Evaluating these polynomials with lots of calls to fact and pow is likely to be inefficient, especially if n is large.

I'm reluctant to go into much detail about what you should do without knowing more about the scope of your assignment -- it will do no one any good for Stack Overflow to do your homework for you! What have you already been told about Bezier curves? What exactly does your assignment ask you to do?

EDITED to add:

The simplest way to do interpolation using Bezier curves is probably this. Have one (cubic) Bezier curve between each pair of key-points. The endpoints (first and last control points) of each Bezier curve are those keypoints. You need two more control points. For motion to be smooth as you move through a given keypoint, you need (keypoint minus previous control point) = (next control point minus keypoint). So you're choosing a single vector at each keypoint, which will determine where the previous and subsequent control points go. As you move through each keypoint, you'll be moving in the direction of that vector, and the longer the vector is the faster you'll be moving. (If the vector is zero then your cubic Bezier degenerates into a simple straight-line path.)

Choosing that vector so that everything looks nice is highly nontrivial, but you probably aren't really being asked to do that at this stage. So something pretty simple will probably be good enough. You might, e.g., take the vector to be proportional to (next keypoint minus previous keypoint). You'll need to do something a bit different at the start and end of your path if you do that.

Finally got What I needed! Here's what I did:

private void interpolate() {    
  float t = 0;
  float x,y,b;
  for(int f =0;f<frames.length;f++) {      
    x=0;
    y=0;
    for(int i = 0; i<keyFrames.length; i++) {       
      b = Bint(i,keyFrames.length-1,map(t,0,time,0,1));   
      x += b*keyFrames[i].x;
      y += b*keyFrames[i].y;
    }    
  frames[f] = new Frame(x,y); 
  t+=partialTime;     
}

}

private void createInterpolationData() {
     time = keyFrames[keyFrames.length-1].time -
     keyFrames[0].time;
     noOfFrames = 60*time;
     partialTime = time/noOfFrames;
     frames = new Frame[ceil(noOfFrames)];  
}