beziercurve.cpp

/* Mondschein Engine is a fast, powerful, and easy-to-use 3D realtime rendering engine.
 *
 * Copyright (C) 2009-2013 by Andreas Amereller
 * E-Mail: andreas.amereller.dev@googlemail.com
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 3 of the License, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#include "core/beziercurve.h"

using namespace mondschein;
using namespace math;

Beziercurve::Beziercurve() : points()
{
  return;
}

Beziercurve::Beziercurve(const std::vector<Eigen::Vector4d> &_p) : points(_p)
{
  return;
}

Beziercurve::Beziercurve(Beziercurve_c _c) : points(_c->points)
{
  return;
}

Beziercurve::~Beziercurve()
{
  return;
}

Beziercurve &Beziercurve::operator=(Beziercurve_c _c)
{
  points=_c->points;
  return *this;
}

Eigen::Vector3d Beziercurve::operator()(float64 _t) const
{
  try
  {
    return get_point(_t);
  }
  catch (exception &e)
  {
    std::string err(*boost::get_error_info<exception_error>(e));
    err+=", called in function\n\t";
    err+="Eigen::Vector3d mondschein::math::Beziercurve::operator()(float64 _t) const";
    throw boost::enable_current_exception(e) << exception_error(err);
  }
}

void Beziercurve::set_points(const std::vector<Eigen::Vector4d> &_p)
{
  points=_p;
  return;
}

std::vector<Eigen::Vector4d> Beziercurve::get_points() const
{
  return points;
}

uint32 Beziercurve::get_degree() const
{
  return points.size()-1;
}

Eigen::Vector3d Beziercurve::get_point(float64 _t) const
{
  if (_t<0) _t=0;
  else if (_t>1) _t=1;

  try
  {
    /* Preparing the point container */
    std::vector<Eigen::Vector3d> v;
    v.clear();
    for (uint32 i=0; i<points.size(); ++i) v.push_back(Eigen::Vector3d(points.at(i)(0)*points.at(i)(3),
          points.at(i)(1)*points.at(i)(3),
          points.at(i)(2)*points.at(i)(3)));

    /* Perform an iterative deCasteljau algorithm */
    for (uint32 j=1; j<v.size(); ++j)
    {
      for (uint32 k=0; k<v.size()-j; ++k)
      {
        v.at(j)=(1-_t)*v.at(j)+_t*v.at(j+1);
      }
    }
    return v.at(0);
  }
  catch (std::exception &e)
  {
    std::string err("Mondschein Engine ERROR: ");
    err+=e.what();
    err+=", exception raised in function\n\t";
    err+="Eigen::Vector3d mondschein::math::Beziercurve::get_curve_point(float64 _t) const";
    throw boost::enable_current_exception(exception()) << exception_error(err);
  }
}