BsplineBasis.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 _GOBSPLINE_H
#define _GOBSPLINE_H

#include <vector>
#include "Values.h"
#include "Streamable.h"

#ifdef NDEBUG
#define CHECK(object)
#else
#define CHECK(object) (object)->check()
#endif

namespace Go
{


class BsplineBasis : public Streamable
{
public:
    BsplineBasis()
        : num_coefs_(0), order_(0), last_knot_interval_(0)
    {
    }

    template <typename RandomIterator>
    BsplineBasis(int number,
                 int order,
                 RandomIterator knotstart)
        : num_coefs_(number), order_(order),
          knots_(knotstart, knotstart + number + order),
          last_knot_interval_(order - 1)
    {
        check();
    }

    template <typename RandomIterator>
    BsplineBasis(int order,
                   RandomIterator knotstart,
                   RandomIterator knotend)
        : num_coefs_(knotend - knotstart - order), order_(order),
          knots_(knotstart, knotend),
          last_knot_interval_(order - 1)
    {
        check();
    }

    virtual ~BsplineBasis();


    template <typename RandomIterator>
    void setData(int number, int order, RandomIterator knotstart)
    {
        num_coefs_ = number;
        order_ = order;
        knots_.clear();
        knots_.insert(knots_.end(), knotstart, knotstart + number + order);
        last_knot_interval_ = order - 1;
    }

    void swap(BsplineBasis& other);

    virtual void read(std::istream& is);

    virtual void write(std::ostream& os) const;

    virtual void read_bin(std::istream& is);

    virtual void write_bin(std::ostream& os) const;

    int knotInterval(double t) const;

    std::vector<double> computeBasisValues(double t, int derivs=0) const;

    void computeBasisValues(double t,
                            double* basisvals_start,
                            int derivs = 0,
                            double resolution=1.0e-12) const; 

    void computeBasisValues(const double* parvals_start,
                            const double* parvals_end,
                            double* basisvals_start,
                            int* knotinter_start,
                            int derivs = 0) const;

    std::vector<double> computeBasisValuesLeft(double tval, int derivs ) const;

    void computeBasisValuesLeft(double tval, 
                                double* basisvals_start,
                                int derivs,
                                double resolution=1.0e-12) const;

    void computeBasisValuesLeft(const double* parvals_start,
                                const double* parvals_end,
                                double* basisvals_start,
                                int* knotinter_start,
                                int derivs) const;

    void reverseParameterDirection();

    void rescale (double new_start, double new_end);

    void insertKnot(double apar);

    int knotIntervalFuzzy(double& t, double tol = DEFAULT_PARAMETER_EPSILON) const;

    void insertKnot(const std::vector<double>& new_knots);

    void removeKnot(double old_knot);

    inline int lastKnotInterval() const;
    
    inline double grevilleParameter(int index) const;

    int knotMultiplicity(const double parval) const;

    int endMultiplicity(bool atstart) const;

    bool isKreg() const
    {
        return (endMultiplicity(true) == order_ &&
                endMultiplicity(false) == order_);
    }

    void coefsAffectingParam(double tpar, int& first_coef, int& last_coef) const;
    
    int numCoefs() const
    { return num_coefs_; }
    
    int order() const
    { return order_; }

    double startparam() const
    { return knots_[order_-1]; }

    double endparam() const
    { return knots_[num_coefs_]; }

    std::vector<double>::const_iterator begin() const
    { return knots_.begin(); }

    std::vector<double>::const_iterator end() const
        { return knots_.end(); }

    std::vector<double>::iterator begin()
        { return knots_.begin(); }
    std::vector<double>::iterator end()
        { return knots_.end(); }

    void check() const;

    // Return the basis for the subspace.
    BsplineBasis subBasis(double tmin, double tmax, double knot_diff_tol = 1e-05) const;

private:
    // Data members
    int num_coefs_;
    int order_;
    std::vector<double> knots_;
    mutable int last_knot_interval_;


};


inline int BsplineBasis::lastKnotInterval() const
{
    return last_knot_interval_;
}


inline double BsplineBasis::grevilleParameter(int index) const
{
   double greville = 0.0;
   for (int i = 1; i < order(); ++i)
      greville += knots_[index+i];

   return greville/(order() - 1.0);
}


} // namespace Go


#endif // This is what is 'ended': #ifndef _GOBspline_H

---