vsr_cga3D_frame.h

Go to the documentation of this file.

/*
 * =====================================================================================
 *
 *       Filename:  vsr_cga3D_frame.h
 *
 *    Description:  position, orientation, velocities, accelerations
 *
 *        Version:  1.0
 *        Created:  03/05/2014 20:11:53
 *       Revision:  none
 *       Compiler:  gcc
 *
 *         Author:  Pablo Colapinto (), gmail -> wolftype
 *   Organization:  
 *
 * =====================================================================================
 */


#ifndef  vsr_cga3D_frame_INC
#define  vsr_cga3D_frame_INC

#include "space/vsr_cga3D_op.h"
 
namespace vsr { namespace cga {
 
//   using namespace types;
  class Frame{

    
    protected:
                         
    Point mPos;   
    Rotor mRot;   
   
    VSR_PRECISION aBiv;    
    Biv dBiv;   
    VSR_PRECISION aVec;    
    Vec dVec;   
    VSR_PRECISION mScale;  

    public:

    // these typedefs help Frame play nice with Field class . . .
    //template< class B > using BType = CGAMV<5, B >;
    using space = typename conformal<5>::types;
    
    Frame();
    Frame(VSR_PRECISION _x, VSR_PRECISION _y, VSR_PRECISION _z);
    Frame(const Vec& v, const Rotor& r = Rot(1,0,0,0), VSR_PRECISION s = 1);
    Frame(const Point& p, const Rotor& r = Rot(1,0,0,0), VSR_PRECISION s = 1 );
    Frame(const DualLine& d );
    Frame(const Motor& m );

    Frame& set( Pnt p, Rot r = Rot(1,0,0,0) ) { mPos = p; mRot = r; return *this; } 
    Frame& scale( VSR_PRECISION s ) { mScale = s; return *this; }    
    Frame& reset() { mPos = Round::point(0,0,0); mRot = Rot(1,0,0,0); return *this; }
    
    VSR_PRECISION scale() const { return mScale; }
    VSR_PRECISION& scale() { return mScale; }

    /*-----------------------------------------------------------------------------
     *  ORIENTATION METHODS (ROTOR, QUATERNION, ETC)
     *-----------------------------------------------------------------------------*/
    //gfx::Mat4f image(){ return xf::mat(mRot); }
    Rotor rot() const { return mRot; }
    Rotor rotor() const { return mRot; }

    Rot& rot() { return mRot; } 
    //  Get Rotor by reference
    Rot& rotor() { return mRot; }     
    Frame& rot( const Rot& r) { mRot = r; return *this; }  
    Frame& rot( const Biv& B) { mRot = Gen::rot(B); return *this; }      
    Rot quat() const { return Rot( mRot[0], -(mRot[3]), (mRot[2]), -(mRot[1]) ); }
    Frame& orient( const Vec& v, bool pos=true); 
    Frame& orient( const Vec& v, float amt, bool pos=true); 
    Frame& orientX( const Vec& v, float amt, bool pos=true); 
    Rotor relOrientRot( const Vec& v,  bool pos=true);
    Biv relOrientBiv( const Vec& v,  bool pos=true);
    Frame& relOrient( const Vec& v, float t,  bool pos=true );
    Motor relMotor( const Frame& target );
    Frame& relTwist( const Frame& target, float t);
    Frame& relTwistAway( const Frame& target, float t);    

    /*-----------------------------------------------------------------------------
     *  POSITION METHODS
     *-----------------------------------------------------------------------------*/
    Point pos() const { return mPos; }  
    Point& pos() { return mPos; }  
    Vec vec() const { return mPos; }   
    Frame& pos( const Vec& v) { mPos = v.null(); return *this; }
    Frame& pos( const Pnt& p ) { mPos = p; return *this; } 
    Frame& pos( VSR_PRECISION _x, VSR_PRECISION _y, VSR_PRECISION _z) { mPos = Round::point(_x,_y,_z); return *this; } 
    //Frame& set( VSR_PRECISION _x, VSR_PRECISION _y, VSR_PRECISION _z) { mPos = Round::null(_x,_y,_z); return *this; }

    
    Vec x() const;    
    Vec y() const;    
    Vec z() const;    

    //Positve and negative axis
    Point posX() const { return (mPos + x()).null(); }
    Point negX() const { return (mPos - x()).null(); } 
    Point posY() const { return (mPos + y()).null(); }
    Point negY() const { return (mPos - y()).null(); }
    Point posZ() const { return (mPos + z()).null(); }
    Point negZ() const { return (mPos - z()).null(); }
    
    Biv xy()  const;    
    Biv xz()  const;    
    Biv yz()  const;    
    
    Lin lx() const;     
    Lin ly() const;     
    Lin lz() const;     
    
    Dll dlx() const;    
    Dll dly() const;    
    Dll dlz() const;    
    
    /* Homogenous Planes in Conformal Space */
    Dlp dxz() const;    
    Dlp dxy() const;    
    Dlp dyz() const;    
    

    /* Real Pair */
    Par px() const;       
    Par py() const;       
    Par pz() const;       

    /* Imaginary Pair */
    Par ipx() const;      
    Par ipy() const;      
    Par ipz() const;      
   
    /* Global Tangent as Null Point Pair*/
    Par tx() const;       
    Par ty() const;       
    Par tz() const;       

    /* Global Weighted Tangent as Null Point Pair*/
    Par tx( VSR_PRECISION v) const;       
    Par ty( VSR_PRECISION v) const;       
    Par tz( VSR_PRECISION v) const;       

    /* Real Circles */
    Cir cxy() const;      
    Cir cxz() const;      
    Cir cyz() const;      

    /* Imaginary Circles */
    Cir icxy() const;     
    Cir icxz() const;     
    Cir icyz() const;     

    Vec right() const { return x(); }
    Vec up() const { return y(); }   
    Vec forward() const { return -z(); }  
  
    Frame& mot(const Mot& m);

    Trs trs() const;
          
    Mot mot() const;

    Motor motor() const;
    
    Dls bound() const;

    Dls ibound() const;
    
    Dll dll() const;
    DualLine dualLine() const;
    
    VSR_PRECISION& ab() { return aBiv; }             
    VSR_PRECISION ab() const { return aBiv; }        
    VSR_PRECISION& ax() { return aVec; }             
    VSR_PRECISION ax() const { return aVec; }        
    Biv& db() { return dBiv; }            
    Biv db() const { return dBiv; }       
    Vec& dx() { return dVec; }            
    Vec dx() const { return dVec; }       
    
    Frame& step();
  
    Frame& move();
    
    Frame& spin();

    Frame& dilate(double t);
    Frame& dilate(const Point& p, double t);

    Frame rotXY( VSR_PRECISION amt) const;

    Frame& move( VSR_PRECISION dx , VSR_PRECISION dy, VSR_PRECISION dz );
    Frame& move( const Vec& v);
    // Spin by Biv
    Frame& rotate( const Biv& b);
    Frame& rotate( const Rot& r);
    Frame& twist( const Dll& );
    Frame& twist( const Mot& );
    Frame& boost( const Par&);
    Frame& boost( const Bst&);

    Frame moveX( VSR_PRECISION amt ) const;
    Frame moveY( VSR_PRECISION amt ) const;
    Frame moveZ( VSR_PRECISION amt ) const;

    //DEPRECATED
    //Frame move( VSR_PRECISION dx , VSR_PRECISION dy, VSR_PRECISION dz ) const;

  };
   
} } //vsr::


#endif   /* ----- #ifndef vsr_cga3D_frame_INC  ----- */