#pragma once

//-----------------------------------------------------------------------------

//  tbezier.h: contains useful function to manipulate bezier polynomious

//-----------------------------------------------------------------------------

#ifndef TBEZIER_H

#define TBEZIER_H

#include <iterator></iterator>

//-----------------------------------------------------------------------------

/*!

  Compute the forward differences.

 */

template <class t=""></class>

void forwardDifferences(const std::vector<t> &coeff, std::vector<t> &diffs) {</t></t>

  diffs.clear();

  std::copy(coeff.begin(), coeff.end(), std::back_inserter(diffs));

  typename std::vector<t>::iterator vectIt;</t>

  const UINT degree = coeff.size();

  for (UINT r = 0; r < degree; ++r) {

    vectIt = diffs.begin();

    std::advance(vectIt, r);

    std::adjacent_difference(vectIt, diffs.end(), vectIt);

  }

}

//-----------------------------------------------------------------------------

/*!

  Converts Bezier form to power (polynomial) form.

  \par  bez coefficients in Bezier form.

  \ret  coeff coefficients of power form.

  \note coeffs are ordered from smaller b[0] to greater b[size-1] .

 */

template <class t=""></class>

void bezier2poly(const std::vector<t> &bez, std::vector<t> &coeff) {</t></t>

  forwardDifferences(bez, coeff);  // compute forward differences

                                   // and store them in coeff.

  int degree = bez.size() - 1;

  double i_factorial = 1, n_r = 1;

  coeff[0] = bez[0];

  for (int i = 1; i < degree; i++) {

    i_factorial = i_factorial * i;

    n_r         = n_r * (degree - i + 1);

    i_factorial = 1.0 / i_factorial;

    coeff[i]    = (n_r * i_factorial) * coeff[i];

  }

}

//-----------------------------------------------------------------------------

/*!

  Converts power (polynomial) form to Bezier form.

  \par  coeff coefficients of power form.

  \ret  bez coefficients in Bezier form.

  \note coeffs are ordered from smaller b[0] to greater b[size-1].

 */

template <class t=""></class>

void poly2bezier(const std::vector<t> &poly, std::vector<t> &bez) {</t></t>

  UINT n = poly.size();

  bez.clear();

  std::copy(poly.begin(), poly.end(), std::back_inserter(bez));

  double c, d, e;

  for (UINT j = 1; j < n; j++) {

    c = 1.0 / (n - j);

    d = 1;

    e = c;

    for (UINT i = n - 1; i >= j; i--) {

      bez[i] = d * bez[i] + e * bez[i - 1];

      d -= c;

      e += c;

    }

  }

}

#endif  // TBEZIER_H

//-----------------------------------------------------------------------------

//  End Of File

//-----------------------------------------------------------------------------