Get smoothing point using B-spline curve C++

edit

I'm working on video stabilization topic. At the smoothing part, I need smooth parameters (translation, rotation+scale) by using B-spline curve for warping in order to create stabilized video.

Now, I am testing on some points. For example, I have 4 points (control points) with degree = 2, after using b-spline I wanna obtain 4 smoothed points. But when I use B-spline curve sample code in below, it created more than 4 points. I can not understand exactly that those results points which are belong to original points (control points). If I only get 4 points, the results is like as 4 original points (4 control points).How to get 4 smoothed points by using B-Spline curve?

Hope you guys help me to show this problem.

Here is the code.

#include "stdafx.h"
#include <stdio.h>
#include <conio.h>
/*
Subroutine to generate a B-spline open knot vector with multiplicity
equal to the order at the ends.

c            = order of the basis function
n            = the number of defining polygon vertices
nplus2       = index of x() for the first occurence of the maximum knot vector value
nplusc       = maximum value of the knot vector -- $n + c$
x()          = array containing the knot vector
*/
void knot(int n, int c, int x[])
{
  int nplusc,nplus2,i;

  nplusc = n + c;
  nplus2 = n + 2;

  x[1] = 0;
  for (i = 2; i <= nplusc; i++){
  if ( (i > c) && (i < nplus2) )
      x[i] = x[i-1] + 1;
  else
     x[i] = x[i-1];
  }
}
/*  Subroutine to generate B-spline basis functions for open knot vectors

 C code for An Introduction to NURBS
 by David F. Rogers. Copyright (C) 2000 David F. Rogers,
 All rights reserved.

 Name: basis.c
 Language: C
 Subroutines called: none
 Book reference: p. 279

 c        = order of the B-spline basis function
 d        = first term of the basis function recursion relation
 e        = second term of the basis function recursion relation
 npts     = number of defining polygon vertices
 n[]      = array containing the basis functions
       n[1] contains the basis function associated with B1 etc.
 nplusc   = constant -- npts + c -- maximum number of knot values
 t        = parameter value
 temp[]   = temporary array
 x[]      = knot vector
 */  

 void basis(int c,float t, int npts,int x[],float n[])
 {
     int nplusc;
     int i,k;
     float d,e;
     float temp[36];

     nplusc = npts + c;

     /* calculate the first order basis functions n[i][1]    */

     for (i = 1; i<= nplusc-1; i++){
          if (( t >= x[i]) && (t < x[i+1]))
               temp[i] = 1;
          else
               temp[i] = 0;
     }

     /* calculate the higher order basis functions */

     for (k = 2; k <= c; k++){
         for (i = 1; i <= nplusc-k; i++){
              if (temp[i] != 0)/* if the lower order basis function is zero skip the                         calculation */
                   d = ((t-x[i])*temp[i])/(x[i+k-1]-x[i]);
              else
                   d = 0;

     if (temp[i+1] != 0)     /* if the lower order basis function is zero skip the calculation  */
        e = ((x[i+k]-t)*temp[i+1])/(x[i+k]-x[i+1]);
    else
        e = 0;

    temp[i] = d + e;
    }
  }

  if (t == (float)x[nplusc]){     /*    pick up last point    */
       temp[npts] = 1;
  }

  /* put in ...