BPointSeq.h

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

#include <vector>
#include "mg/MGCL.h"

// MGBPointSeq.h
//

//Forward Declaration
class MGIfstream;
class MGOfstream;
class MGBox;
class MGVector;
class MGPosition;
class MGSPointSeq;
class MGMatrix;
class MGTransf;
class MGPlane;
class MGStraight;


class MG_DLL_DECLR MGBPointSeq {

public:

MG_DLL_DECLR friend MGBPointSeq operator+(const MGVector& v, const MGBPointSeq& b);

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

MG_DLL_DECLR friend std::ostream& operator<< (std::ostream&, const MGBPointSeq&);


explicit MGBPointSeq(int capacity=0, int dim=0);

MGBPointSeq(int dim,        
    const MGBPointSeq& old_brep,
    int start1=0,       
    int start2=0            
);

MGBPointSeq(
    bool along_u,   
    int m,  
    const MGSPointSeq& sp   
);

MGBPointSeq(
    int start_id,   
    int num,            
    const MGBPointSeq& bp_old
);

MGBPointSeq(const std::vector<MGPosition>& poses);

MGBPointSeq(const MGBPointSeq&); 

~MGBPointSeq(){if(m_bpoint) delete[] m_bpoint;};


MGBPointSeq& operator= (const MGBPointSeq&);

double& operator()(int i, int j){   
    assert(i<capacity()&&j<m_sdim);
    return m_bpoint[i+m_capacity*j];
}

double operator()(int i, int j) const{return ref(i,j);};

MGVector operator() (int i) const;

MGBPointSeq operator+(const MGVector& v) const;

MGBPointSeq& operator+= (const MGVector&);

MGBPointSeq operator- (const MGVector&) const;

MGBPointSeq& operator-= (const MGVector&);

MGBPointSeq operator+ (const MGBPointSeq& bp2) const;

MGBPointSeq& operator+= (const MGBPointSeq& bp2);

MGBPointSeq operator- (const MGBPointSeq& bp2) const;

MGBPointSeq& operator-= (const MGBPointSeq& bp2);

MGBPointSeq operator* (double scale) const;

MGBPointSeq& operator*= (double scale);

MGBPointSeq operator/ (double scale) const;

MGBPointSeq& operator/= (double scale);

MGBPointSeq operator* (const MGMatrix&) const;

MGBPointSeq& operator*= (const MGMatrix&);

MGBPointSeq operator* (const MGTransf&) const;

MGBPointSeq& operator*= (const MGTransf&);                            

bool operator== (const MGBPointSeq& ) const;

bool operator!= (const MGBPointSeq& brep) const
{return !(operator== (brep));}


int average_plane(
    MGPosition& center  
    , MGPlane& plane    
    , MGStraight& line  
    , double& deviation
)const;

MGBox box()const;

void coordinate_exchange(int j1, int j2);

double* data(int i=0, int j=0);

const double* data(int i=0, int j=0)const;

void insert_at(
    int i,  
    const MGVector& vctr
);

void insert_at(int i,   
    const double* data  
);

bool is_null()const{return m_sdim==0;};

int length()const{return m_length;};

void negate();

MGBPointSeq non_homogeneous()const;

int planar(
    MGPlane& plane  
    , MGStraight& line  
    , MGPosition& center
)const;

void point(int i, int j, int sd, MGPosition& P)const;

double ref(int i, int j) const;

void reshape(
    int capacity
    , int start=0
);                                

//dim=0 means space dimension be set same as the old one.
void resize(int sz, int dim=0);

int sdim() const {return m_sdim;}

void set_length(int length);

void set_null();

int capacity() const {return m_capacity;}

void store_at(int i,    
    const MGVector& vctr,
    int to=0,   
    int from=0  
);

void store_at(int i,    
    const MGVector& vctr,
    int to, 
    int from,
    int len
);

void store_at(int i,    
    const double* data, 
    int to=0
);

MGBPointSeq& homogeneous_transform(double);

MGBPointSeq& homogeneous_transform(const MGVector&);

MGBPointSeq& homogeneous_transform(const MGMatrix&);

MGBPointSeq& homogeneous_transform(const MGTransf&);

int dump_size() const;

int dump(MGOfstream& ) const;

int restore(MGIfstream& );
    
private:
    int m_capacity; 
    int m_sdim;     
    int m_length;   
    double* m_bpoint;   

MGBox* compute_box()const;

friend class MGLBRep;
friend class MGRLBRep;
};
 // end of BASE group
#endif