SplineCurve.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 _GOSPLINECURVE_H
#define _GOSPLINECURVE_H


#include "DirectionCone.h"
#include "ParamCurve.h"
#include "BsplineBasis.h"


namespace Go
{


class Interpolator;

class SplineCurve : public ParamCurve
{
public:

    SplineCurve() : dim_(-1), rational_(false) { }

    template <typename RandomIterator1, typename RandomIterator2>
    SplineCurve(int number,
                  int order,
                  RandomIterator1 knotstart,
                  RandomIterator2 coefsstart,
                  int dim,
                  bool rational = false)
        : dim_(dim), rational_(rational),
          basis_(number, order, knotstart)
    {
        if (rational) {
            rcoefs_.resize((dim+1)*number);
            std::copy(coefsstart, coefsstart+(dim+1)*number, 
                      rcoefs_.begin());
            coefs_.resize(dim*number);
            updateCoefsFromRcoefs();
        } else {
            coefs_.resize(dim*number);
            std::copy(coefsstart, coefsstart + dim*number, 
                      coefs_.begin());
        }
    }

    SplineCurve(const Point& pnt1, const Point& pnt2);

    SplineCurve(const Point& pnt1, double startpar, 
                const Point& pnt2, double endpar);

    virtual ~SplineCurve();

    // Inherited from Streamable
    virtual void read (std::istream& is);

    // Inherited from Streamable
    virtual void write (std::ostream& os) const;

    // Inherited from GeomObject
    virtual BoundingBox boundingBox() const;

    // Inherited from GeomObject
    virtual int dimension() const;

    // Inherited from GeomObject
    virtual ClassType instanceType() const;

    // Inherited from GeomObject
    static ClassType classType()
    { return Class_SplineCurve; }
    // Inherited from GeomObject
// #if ((_MSC_VER > 0) && (_MSC_VER < 1300))
//     virtual GeomObject* clone() const
//     { return new SplineCurve(*this); }
// #else
    virtual SplineCurve* clone() const
    { return new SplineCurve(*this); }
// #endif

    // Inherited from ParamCurve
    virtual void point(Point& pt, double tpar) const;

    // Inherited from ParamCurve
    virtual void point(std::vector<Point>& pts, 
                       double tpar,
                       int derivs,
                       bool from_right = true) const;

    // Inherited from ParamCurve
    virtual double startparam() const;

    // Inherited from ParamCurve
    virtual double endparam() const;

    // Inherited from ParamCurve
    virtual void reverseParameterDirection(bool switchparam = false);

    // Inherited from ParamCurve
    virtual SplineCurve* geometryCurve();

    // Inherited from ParamCurve
    virtual DirectionCone directionCone() const;

    // Inherited from ParamCurve
    virtual CompositeBox compositeBox() const;

    // Inherited from ParamCurve
    virtual bool isDegenerate(double degenerate_epsilon);


    SplineCurve* derivCurve(int ider) const;

    // Inherited from ParamCurve
#if ((_MSC_VER > 0) && (_MSC_VER < 1300))
    virtual ParamCurve* subCurve(double from_par, double to_par,
                                 double fuzzy 
                                 = DEFAULT_PARAMETER_EPSILON) const;
#else
    virtual SplineCurve* subCurve(double from_par, double to_par,
                                  double fuzzy 
                                  = DEFAULT_PARAMETER_EPSILON) const;
#endif

    // Inherited from ParamCurve
    virtual void closestPoint(const Point& pt,
                              double         tmin,
                              double         tmax,
                              double&        clo_t,
                              Point&         clo_pt,
                              double&        clo_dist,
                              double const   *seed = 0) const;

    virtual void appendCurve(ParamCurve* other_curve,
                             int continuity, 
                             double& dist, 
                             bool repar=true);
    
    virtual void appendCurve(ParamCurve* cv, bool repar=true);

    const BsplineBasis& basis() const
    { return basis_; }

    BsplineBasis& basis()
    { return basis_; }

    int numCoefs() const
    { return basis_.numCoefs(); }

    int order() const
    { return basis_.order(); }

    bool rational() const
    { return rational_; }

    std::vector<double>::iterator knotsBegin()
    { return basis_.begin(); }
    std::vector<double>::iterator knotsEnd()
    { return basis_.end(); }
    std::vector<double>::const_iterator knotsBegin() const
    { return basis_.begin(); }
    std::vector<double>::const_iterator knotsEnd() const
    { return basis_.end(); }


    std::vector<double>::iterator coefs_begin() 
    { return coefs_.begin(); }
    std::vector<double>::iterator coefs_end() 
    { return coefs_.end(); }
    std::vector<double>::const_iterator coefs_begin() const 
    { return coefs_.begin(); }
    std::vector<double>::const_iterator coefs_end() const 
    { return coefs_.end(); }
    std::vector<double>::iterator rcoefs_begin() 
    { return rcoefs_.begin(); }
    std::vector<double>::iterator rcoefs_end() 
    { return rcoefs_.end(); }
    std::vector<double>::const_iterator rcoefs_begin() const 
    { return rcoefs_.begin(); }
    std::vector<double>::const_iterator rcoefs_end() const 
    { return rcoefs_.end(); }

    void interpolate(Interpolator& interpolator,
                     int num_points,
                     int dim,
                     const double* param_start,
                     const double* data_start);

    void insertKnot(double apar);

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

    void makeBernsteinKnots();

    void setParameterInterval(double t1, double t2);

    void removeKnot(double tpar);

    void raiseOrder(int i = 1);

    void makeKnotStartRegular();

    void makeKnotEndRegular();

    void swap(SplineCurve& other);

    virtual double nextSegmentVal(double par, bool forward, 
                                  double tol) const;


private:
    // Canonical data
    int dim_;
    bool rational_;
    BsplineBasis basis_;
    std::vector<double> coefs_;   
    std::vector<double> rcoefs_;  


    // Helper functions
    void updateCoefsFromRcoefs();
    void appendSelfPeriodic();

};


} // namespace Go



#endif // _GOSPLINECURVE_H

---