KnotVector.h

/********************************************************************/
/* Copyright (c) 2015 DG Technologies Inc. and Yuzi Mizuno          */
/* All rights reserved.                                             */
/********************************************************************/
#ifndef _MGKnotVector_HH_
#define _MGKnotVector_HH_

#include "mg/NDDArray.h"

// MGKnotVector.h
//
// Forward declaration
class MGNDDArray;
class MGKnotArray;
class MGIfstream;
class MGOfstream;


class MG_DLL_DECLR MGKnotVector :public MGNDDArray{

public:

MG_DLL_DECLR friend MGKnotVector operator*(double scale, const MGKnotVector& t);

MG_DLL_DECLR friend std::ostream& operator<<(std::ostream& strm, const MGKnotVector& t);


explicit MGKnotVector(
    int order=0,    
    int bdim=0, 
    const double* data=0    
);

MGKnotVector(
    int order,      
    int bdim,       
    double init_value,      
    double increment=1.0
);

MGKnotVector(
    const MGNDDArray& dtp,  
    int order   
);

MGKnotVector(
    const MGKnotVector& vec2,   
    const MGKnotArray& knots    
);

MGKnotVector(
    int start_id,           
    int num,                    
    const MGKnotVector& vec2    
);

MGKnotVector(
    const MGKnotVector& knotv,  
    int order               
);

MGKnotVector(const MGKnotVector& knotv, double t1, double t2);

MGKnotVector(const MGKnotVector& vec2);

//Destructor
//
//  ~MGKnotVector();    //We use default destructor.


MGKnotVector& operator=(const MGKnotVector& vec2);

MGKnotVector operator+ (double) const;
MGKnotVector& operator+= (double);
MGKnotVector operator- (double) const;
MGKnotVector& operator-= (double);

MGKnotVector operator- () const;

MGKnotVector operator* (double) const;
MGKnotVector& operator*= (double);

bool operator== (const MGKnotVector& ) const;    
bool operator!= (const MGKnotVector& knotv) const 
{return !(operator== (knotv));}


int bdim() const{return length()-m_order;}; 

MGKnotVector& change_knot_number(int nnew);

MGKnotVector& change_order(int order);  

void change_range(double ts, double te);

void divide_span(int num);

int eval_coef(
    double x,       
    double* coef,   
    int nderiv=0,
    int left=0      
)const;

bool in_range(double t) const;

int locate(double tau, int left) const;
int locate(double tau) const;

int locate_multi(int start, int multi, int& index) const;
    
MGKnotVector& mix_knot_vector(const MGKnotVector& knot);

int order() const{return m_order;};

double param_e() const{return MGNDDArray::operator() (bdim());};

double param_s() const{return MGNDDArray::operator() (m_order-1);};

double param_error()const;

double param_span() const;

double param_normalize(double t) const;

double range(double t) const;

void reverse();

double reverse_param(double t) const;

MGKnotVector& set_bdim(int brdim);

void set_null(){MGNDDArray::set_null();m_order=m_current=0;};

int dump_size() const;

int dump(MGOfstream& ) const;

void size_change(int order, int bdim);

int restore(MGIfstream& );


private:
    int   m_order;      

void new_knot_coef(const MGKnotVector&, 
    int j_of_t, 
    double* coef 
);

};
 // end of BASE group
#endif