Position.h

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

#include "mg/Vector.h"

// MGPosition.h
// Header for MGPosition.

// Forward Declaration.
class MGMatrix;
class MGTransf;
class MGPoint;
class MGCurve;
class MGSurface;
class MGCParam_list;
class MGPosition_list;
class MGIfstream;
class MGOfstream;

class MG_DLL_DECLR MGPosition{

public:

inline friend 
MGPosition operator+(const MGPosition& p1,const MGVector& vec){return p1.m_element+vec;};
inline friend 
MGPosition operator+(const MGPosition& p1,const MGPosition& p2){return p1.m_element+p2.m_element;};
inline friend 
MGPosition operator+ (const MGVector& v, const MGPosition& p){return v+p.m_element;};

inline friend 
MGVector operator-(const MGPosition& p1,const MGPosition& p2){return p1.m_element-p2.m_element;}

inline friend 
MGPosition operator-(const MGPosition& p1,const MGVector& v){return p1.m_element-v;}

inline friend 
MGPosition operator-(const MGVector& v,const MGPosition& p1){return v-p1.m_element;}

inline friend 
double operator%(const MGPosition& p1,const MGVector& v){return p1.m_element%v;};
    
MG_DLL_DECLR friend 
MGPosition operator*(const MGPosition& p1,const MGMatrix& mat);

MG_DLL_DECLR friend 
MGPosition operator*(const MGPosition& p1,const MGTransf& tr);

inline friend 
MGPosition operator*(double s, const MGPosition& p){return p*s;};

inline friend 
MGPosition operator*(const MGPosition& p1,double s){return p1.m_element*s;};

inline friend 
MGPosition operator/(const MGPosition& p1,double s){return p1.m_element/s;};

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

MG_DLL_DECLR friend bool operator==(const MGPosition& p1,const MGPosition& p2);
MG_DLL_DECLR friend bool operator==(const MGVector& p1,const MGPosition& p2);
MG_DLL_DECLR friend bool operator==(const MGPosition& p1,const MGVector& p2);
inline friend 
bool operator!=(const MGPosition& p1,const MGPosition& p2){return !(p1==p2);};
inline friend 
bool operator!=(const MGVector& p1,const MGPosition& p2){return !(p1==p2);};
inline friend 
bool operator!=(const MGPosition& p1,const MGVector& p2){return !(p1==p2);};

inline friend 
bool operator<(const MGPosition& p1,const MGPosition& p2){return p1.m_element<p2.m_element;};
inline friend 
bool operator<=(const MGPosition& p1,const MGPosition& p2){return p1.m_element<=p2.m_element;};
inline friend 
bool operator>(const MGPosition& p1,const MGPosition& p2){return p1.m_element>p2.m_element;};
inline friend 
bool operator>=(const MGPosition& p1,const MGPosition& p2){return p1.m_element>=p2.m_element;};


MGPosition(const MGPoint& point);

MGPosition(const MGVector& vec): m_element(vec){;};

explicit MGPosition(int sdim=0):m_element(sdim,0.0){;};

MGPosition(double x, double y):m_element(x,y){;};

MGPosition(double x, double y, double z):m_element(x,y,z){;};

MGPosition(double x, double y, double z, double w):m_element(x,y,z,w){;};

MGPosition(int sdim, const double* v ):m_element(sdim,v){;};

MGPosition(int sdim, const MGPosition& p
            , int start1=0, int start2=0)
            :m_element(sdim, p, start1, start2){;};

MGPosition(const std::vector<double>& darrays): m_element(darrays){;};


//  ~MGPosition(); We use default destructor.


MGPosition& operator=(const double* a);

double operator[] (int i) const{return m_element.ref(i);}
double operator() (int i) const{return m_element.ref(i);}

double& operator()(int i){return m_element(i);};

MGPosition& operator+= (const MGVector& vec);
MGPosition& operator+= (const MGPosition& pos);

MGPosition operator- () const;

MGPosition& operator-= (const MGVector& vec);

MGPosition& operator*=(double scale);

MGPosition& operator*= (const MGMatrix&);

MGPosition& operator*= (const MGTransf&);

MGPosition& operator/= (double);


double angle(
    const MGPosition& start,
    const MGPosition& end,
    const MGVector& normal
)const;

MGPosition& clear(double init=0.0);

double closest(const MGCurve& curve) const;

MGPosition closest(const MGSurface& surf) const;

MGPosition* clone() const{return new MGPosition(*this);};

const double* data()const{return m_element.data();};
double* data(){return m_element.data();};

double distance(const MGPosition& P2)const;

MGPosition interpolate(double t2, const MGPosition& vec2) const;

bool is_collinear(
    const MGPosition& P2,
    const MGPosition& P3
)const{return m_element.is_collinear(P2,P3);};

bool is_null()const{return m_element.is_null();};

double len() const{ return m_element.len();};

bool on(
    const MGCurve& curve,   
    double& t   
) const;

bool on(
    const MGSurface& surf,  
    MGPosition& uv  
) const;

int out_to_IGES(
    MGIgesOfstream& igesfile,
    int SubordinateEntitySwitch=0
)const;

double param(const MGCurve& crv) const;

MGPosition param(const MGSurface& srf) const;

MGCParam_list perps(
    const MGCurve& crv      
)const;

MGPosition_list perps(
    const MGSurface& srf    
) const;

MGVector project(const MGVector& v2) const{return m_element.project(v2);};

double ref(int i) const{return m_element.ref(i);}

void resize(int new_sdim){m_element.resize(new_sdim);};

int sdim() const {return m_element.sdim();}

void set_null(){m_element.set_null();}

void store_at(
    int i,              
    const MGVector& vec2,   
    int j=0         
);

void store_at(
    int i,              
    const MGVector& vec2,   
    int j,              
    int len         
);

void swap(int i, int j){m_element.swap(i,j);};

const MGVector& vector() const{ return m_element;}

int dump_size() const;

int dump(MGOfstream& ) const;

int restore(MGIfstream& );

private:
    MGVector m_element;     

};


MG_DLL_DECLR bool is_collinear(
    const MGPosition& P1,
    const MGPosition& P2,
    const MGPosition& P3
);

namespace MGCL{


inline double angle(const MGVector& V1, const MGVector& V2, const MGVector& N){
    return V1.angle2pai(V2,N);
};


inline double angle(
    const MGPosition& origin,
    const MGPosition& P1,
    const MGPosition& P2,
    const MGVector& N
){
    return origin.angle(P1,P2,N);
};

};
 // end of BASE group
#endif