///////////////////////////////////////////////////

//      GBezier Class

//

//      T : 계산에 쓰이는 타입 ( 사용자입장에서 고려할 필요가없다.)

//          D는 더블형을 쓴다 느리다. 그러나 값손실이 적다.

//          Fixed 는 빠르다.

//      F : 계산된 값이 들어가는 타입 (사용자가 고려할 타입 )

//

//    Usage : GTBezier<Type1, Type2> bez;

//

//            GBezierD bez;  // int형의 double형계산

//

//

///////////////////////////////////////////////////

#ifndef _GBezier_

#define _GBezier_

#define GBezierD    GTBezier<double,int>

#define GBezier     GTBezier<GFixed,int>

#define GDBezierD   GTBezier<double,double>

template < class T, class F>

class GTBezier{

    F m_nPoints[8];

    int m_nNpts;

    T BezierSplit( T mu, T x1, T x2 );

    T BezierValue( T mu, F* coor );

public:

    GTBezier();

    GTBezier( F pPoint[8] );

    GTBezier( const GTBezier& csBezier );

    ~GTBezier();

    void Calculate( F* x , F* y, int npts = -1 );

};

#endif

----------

#include "GTBezier.h"

template <class T, class F>

GTBezier<T,F>::GTBezier()

{

    m_nNpts = 0;

    m_nPoints[0]=m_nPoints[1]=m_nPoints[2]=m_nPoints[3]=\

    m_nPoints[4]=m_nPoints[5]=m_nPoints[6]=m_nPoints[7]=0;

}

template <class T, class F>

GTBezier<T,F>::GTBezier(  F pPoint[8] )

{

    m_nNpts = 10;

    for( int i = 0; i<8 ; i++)

    {

        m_nPoints[i] = pPoint[i];

    }

}

template <class T, class F>

GTBezier<T,F>::GTBezier( const GTBezier<T,F>& csBezier  )

{

    m_nNpts = csBezier.m_nNpts;

    for( int i = 0; i<8 ; i++)

    {

        m_nPoints[i] = F(csBezier.m_nPoints[i]);

    }

}

template <class T, class F>

GTBezier<T,F>::~GTBezier()

{

}

template <class T, class F>

T GTBezier<T,F>::BezierSplit( T mu, T x1, T x2 )

{

   return ( (T(1.0) - mu) *x1)+(mu*x2);

   //fmul((itofix(1.0)-mu), x1) + fmul(mu, x2);

}

template <class T, class F>

T GTBezier<T,F>::BezierValue( T mu, F *coor )

{

   T work[4];

   int i;

   int j;

   for (i=0; i<4; i++)

      work[i] = T(coor[i*2]);

      //itofix(coor[i*2]);

   for (j=0; j<3; j++)

      for (i=0; i<3-j; i++)

         work[i] = BezierSplit(mu, work[i], work[i+1]);

   return work[0];

}

template <class T, class F>

void GTBezier<T,F>::Calculate( F* x , F* y, int npts )

{

    if( npts <0 ) npts = m_nNpts;

    int i;

    T   denom;

    for (i=0; i < npts; i++)

    {

        denom = T(i) / T(npts-1);

        //fdiv(itofix(i), itofix(npts-1));

        x[i] = int( BezierValue( denom , m_nPoints ));

        //fixtoi(bezval(denom, points));

        y[i] = int( BezierValue( denom , m_nPoints + 1 ));

        //fixtoi(bezval(denom, points+1));

    }

}

-------------

#include <iostream.h>

#include "GTBezier.h"

#include "GTBezier.cpp"

int main()

{

    int pt[8] = { 0,0, 60, 5,  20,15 , 80,23 };

    GBezierD bez(pt);

    int ptx[10],pty[10];

    bez.Calculate ( ptx, pty, 20 );

    for ( int p = 0 ; p < 20 ; p ++)

    {

        cout << ptx[p] << " " << pty[p] << endl;

    }

}