SplineInterpolator.h

//===========================================================================
// GoTools - SINTEF Geometry Tools version 1.1
//
// GoTools module: CORE
//
// Copyright (C) 2000-2007 SINTEF ICT, Applied Mathematics, Norway.
//
// 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 version 2 of the License. 
//
// 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.,                                                      
// 59 Temple Place - Suite 330,                                           
// Boston, MA  02111-1307, USA.                                           
//
// Contact information: E-mail: tor.dokken@sintef.no                      
// SINTEF ICT, Department of Applied Mathematics,                         
// P.O. Box 124 Blindern,                                                 
// 0314 Oslo, Norway.                                                     
//
// Other licenses are also available for this software, notably licenses
// for:
// - Building commercial software.                                        
// - Building software whose source code you wish to keep private.        
//===========================================================================
#ifndef _GOSPLINEINTERPOLATOR_H
#define _GOSPLINEINTERPOLATOR_H


#include "Interpolator.h"
#include "BsplineBasis.h"
#include "Point.h"
#include <boost/smart_ptr.hpp>


namespace Go
{


class SplineInterpolator : public Interpolator
{
public:
    SplineInterpolator()
        : ctype_(None), basis_set_(false)
        {
        }

    virtual ~SplineInterpolator();

    // inherited from Interpolator
    virtual const BsplineBasis& basis();

    void interpolate(const std::vector<double>& params,
                     const std::vector<double>& points,
                     const std::vector<int>& tangent_index,
                     const std::vector<double>& tangent_points,
                     int order,
                     std::vector<double>& coefs);

    void interpolate(const std::vector<double>& params,
                     const std::vector<double>& points,
                     const std::vector<int>& tangent_index,
                     const std::vector<double>& tangent_points,
                     std::vector<double>& coefs);

    virtual void interpolate(int num_points, int dimension,
                             const double* param_start,
                             const double* data_start,
                             std::vector<double>& coefs);

    enum CondType { None, Hermite, Natural, Free, NaturalAtStart, NaturalAtEnd };

    void setHermiteConditions(const Point& start_tangent,
                              const Point& end_tangent) {
        ctype_ = Hermite;
        start_tangent_ = boost::shared_ptr<Point>(new Point(start_tangent));
        end_tangent_ =  boost::shared_ptr<Point>(new Point(end_tangent));
    }

    void setNaturalConditions() { ctype_ = Natural; }

    void setNaturalStartCondition() { ctype_ = NaturalAtStart;}

    void setNaturalEndCondition() { ctype_ = NaturalAtEnd; }

    void setFreeConditions() { ctype_ = Free; }

    void setEndTangents(boost::shared_ptr<Point>& start_tangent,
                        boost::shared_ptr<Point>& end_tangent)
    {
        start_tangent_ = start_tangent;
        end_tangent_ = end_tangent;
        if (start_tangent.get() != 0 && end_tangent.get() != 0)
            ctype_ = Hermite;
        else if (start_tangent.get() != 0)
            ctype_ = NaturalAtEnd;
        else if (end_tangent.get() != 0)
            ctype_ = NaturalAtStart;
        else
            ctype_ = Natural;
    }

    CondType getCondType() {return ctype_; }

    void makeBasis(const std::vector<double>& params,
                   const std::vector<int>& tangent_index,
                   int order);


    void setBasis(BsplineBasis& basis) {
        basis_ = basis;
        basis_set_ = true;
    }

private:
    CondType ctype_;
    boost::shared_ptr<Point> start_tangent_;
    boost::shared_ptr<Point> end_tangent_;
    BsplineBasis basis_;
    bool basis_set_;
};



} // namespace Go


#endif // _GOSPLINEINTERPOLATOR_H

---