Transf.h

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

#include <glm/glm.hpp>
#include "mg/Default.h"
#include "mg/Vector.h"
#include "mg/Matrix.h"

//  Defines class MGTransf

//  Forward Declarations
class MGUnit_vector;
class MGPosition;
class MGIfstream;
class MGOfstream;
class MGIgesOfstream;
class MGObject;


class MG_DLL_DECLR MGTransf {

public:

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

MG_DLL_DECLR friend MGTransf operator* (const MGVector& v, const MGTransf& tr);

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


explicit MGTransf(int dim=0);

MGTransf(const MGMatrix&, const MGVector&);

MGTransf(double scale, const MGVector&);

MGTransf (int sdim, const MGTransf& transf,
            int start1=0, int start2=0);


MGTransf(double scalex, double scaley);

MGTransf(const MGUnit_vector& unit,  
         const MGPosition& origin    
);


MGTransf(double scalex, double scaley, double scalez);

MGTransf(const MGUnit_vector& uvecx, 
         const MGUnit_vector& uvecy, 
         const MGPosition& P        
 ); 

MGTransf(
    const MGPosition& P0, const MGPosition& P1,
    const MGPosition& Q0, const MGPosition& Q1);


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

double& operator() (int i, int j) ;

MGObject& operator()(MGObject& object);
MGObject* operator()(MGObject* object);

MGTransf operator+ (const MGVector&) const;

MGTransf& operator+= (const MGVector&);

MGTransf operator- (const MGVector&) const;

MGTransf& operator-= (const MGVector&);

MGTransf operator* (double scale) const;

MGTransf operator* (const MGMatrix&) const;

MGTransf operator* (const MGTransf& ) const;

MGTransf& operator*= (double scale);

MGTransf& operator*= (const MGMatrix&);

MGTransf& operator*= (const MGTransf&);

bool operator== (const MGTransf&) const;
bool operator!= (const MGTransf&) const;


const MGMatrix& affine() const{return m_affine;};

void convert_to_glMatrix(
    glm::mat4& glMatI//double glMat[16] ///OpenGL Matrix will be output.
)const;

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

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

double ref(int i, int j) const;

void resize(int sdim);

double scale()const{return m_affine.scale();};

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

MGTransf& set_matrix(const MGMatrix& mat, const MGPosition& point);
   
void set_null();

MGTransf& set_reflect_2D(   const MGVector& vec,
                            const MGPosition& P= mgORIGIN_2D);

MGTransf& set_rotate_2D(    double angle,
                            const MGPosition& P= mgORIGIN_2D); 

MGTransf& set_reflect_3D(
    const MGVector&,
    const MGPosition& P= mgORIGIN);

MGTransf& set_rotate_3D(
    const MGVector& vec,
    double angle,                                      
    const MGPosition& P= mgORIGIN); 

MGTransf& set_scale(double scale);

MGTransf& set_diff_scale(double* scale);

MGTransf& set_glMatrix(const double glMat[16]);

const MGVector& translation() const{return m_translation;};

int dump_size() const;

int dump(MGOfstream& ) const;

int restore(MGIfstream& );

private:

  MGMatrix m_affine;        
  MGVector m_translation;   

};
 // end of BASE group
#endif