axes.h

Go to the documentation of this file.

#pragma once

#include "vect.h"
#include "avect.h"
#include "orientation.h"


class Axes2D {
public:
    BASE_EXPORT Axes2D() { }
    BASE_EXPORT Axes2D(const Axes2D &a) : c_(a.c_), d1_(a.d1_), d2_(a.d2_) { }
    BASE_EXPORT Axes2D(const DVect2 &vx,const DVect2 &vy,const DVect2 &c=DVect2(0));
    BASE_EXPORT explicit Axes2D(const Double &dip,const DVect2 &c=DVect2(0)) { setOrientation(dip); setOrigin(c); }
    BASE_EXPORT explicit Axes2D(const Orientation2 &o,const DVect2 &c=DVect2(0)) { setOrientation(o);  setOrigin(c); }

    BASE_EXPORT const Axes2D &operator=(const Axes2D &a) { d1_=a.d1_; d2_=a.d2_; c_=a.c_; return *this; }
    BASE_EXPORT bool operator==(const Axes2D &a) const;
    BASE_EXPORT bool operator!=(const Axes2D &a) const { return !operator==(a); }

    BASE_EXPORT void setOrigin(const DVect2 &c) { c_=c; }
    BASE_EXPORT void setOrientation(const Double &dip); 
    BASE_EXPORT void setOrientation(const Orientation2 &o);

    BASE_EXPORT const DVect2 &c() const { return c_; }
    BASE_EXPORT const DVect2 &e1() const { return d1_; }
    BASE_EXPORT const DVect2 &e2() const { return d2_; }
    //   Note:  If you use these - no checks are made to ensure vectors are orthonormal!

    BASE_EXPORT DVect2 &rc() { return c_; }
    BASE_EXPORT DVect2 &re1() { return d1_; }
    BASE_EXPORT DVect2 &re2() { return d2_; }

    BASE_EXPORT DVect2 toLocal(const DVect2 &v) const;
    BASE_EXPORT const DAVect2 &toLocal(const DAVect2 &v) const { return v; }
    BASE_EXPORT DVect2 toGlobal(const DVect2 &v) const;
    BASE_EXPORT const DAVect2 &toGlobal(const DAVect2 &v) const { return v; }
    BASE_EXPORT DVect2 getDir(unsigned int dof) const;
    BASE_EXPORT void   setDir(unsigned int dof,const DVect2 &v);
    BASE_EXPORT void   setDirAuto(unsigned int dof,unsigned int keepDOF=0xFFFFFFFF);
    BASE_EXPORT Orientation2 getOrientation(unsigned int dof=0) const;

    // Static
    static BASE_EXPORT Axes2D make(const DVect2 &y);
    static BASE_EXPORT Axes2D makeX(const DVect2 &x);
    static BASE_EXPORT Axes2D make(const Orientation2 &o);
    static BASE_EXPORT Axes2D makeX(const Orientation2 &o);
    // Makes a default axes assuming dir only is specified.
    static BASE_EXPORT Axes2D make(const DVect2 &dir,unsigned dof);
    static BASE_EXPORT Axes2D makeDef() { Axes2D a(DVect2(1,0),DVect2(0,1));  return a; }
    static BASE_EXPORT void setTolerance(const double &d);
    static BASE_EXPORT double getTolerance();
    static BASE_EXPORT Axes2D global() { return Axes2D(DVect2(1,0),DVect2(0,1)); }
private:
    DVect2 c_;
    DVect2 d1_;
    DVect2 d2_;
};




class Axes3D {
public:
    BASE_EXPORT Axes3D() { }
    BASE_EXPORT Axes3D(const Axes3D &a) : c_(a.c_), d1_(a.d1_), d2_(a.d2_), d3_(a.d3_) { }
    BASE_EXPORT explicit Axes3D(const Axes2D &a) : c_(toVect3(a.c())), d1_(toVect3(a.e1())), d2_(toVect3(a.e2())), d3_(0,0,1) { }
    BASE_EXPORT Axes3D(const DVect3 &vx, const DVect3 &vy, const DVect3 &vz, const DVect3 &c=DVect3(0));
    BASE_EXPORT Axes3D(const Double &dip, const Double &ddir, const Double &roll=0.0, const DVect3 &c=DVect3(0)) { setOrientation(dip,ddir,roll); setOrigin(c); }
    BASE_EXPORT explicit Axes3D(const Orientation3 &o,const Double &roll=0.0,const DVect3 &c=DVect3(0)) { setOrientation(o,roll); setOrigin(c); }

    BASE_EXPORT const Axes3D &operator=(const Axes3D &a) { d1_=a.d1_; d2_=a.d2_; d3_=a.d3_; c_=a.c_; return *this; }
    BASE_EXPORT bool operator==(const Axes3D &a) const;
    BASE_EXPORT bool operator!=(const Axes3D &a) const { return !operator==(a); }

    BASE_EXPORT void setOrigin(const DVect3 &c) { c_=c; }
    BASE_EXPORT void setOrientation(const Double &dip, const Double &ddir, const Double &roll=0.0);  // radians
    BASE_EXPORT void setOrientation(const Orientation3 &o,const Double &roll=0.0);

    // These return the unit vectors e1,e2,e3, defining an orthonormal basis....
    BASE_EXPORT const DVect3 &c() const { return c_; }
    BASE_EXPORT const DVect3 &e1() const { return d1_; }
    BASE_EXPORT const DVect3 &e2() const { return d2_; }
    BASE_EXPORT const DVect3 &e3() const { return d3_; }

    BASE_EXPORT DVect3 &rc() { return c_; }
    BASE_EXPORT DVect3 &re1() { return d1_; }
    BASE_EXPORT DVect3 &re2() { return d2_; }
    BASE_EXPORT DVect3 &re3() { return d3_; }
    BASE_EXPORT DVect3 &rdof(unsigned dof) { if (!dof) return d1_; else if (dof==1) return d2_; else if (dof==2) return d3_;  else return c_; }

    BASE_EXPORT DVect3 toLocal(const DVect3 &v) const;
    BASE_EXPORT DVect3 toGlobal(const DVect3 &v) const;
    BASE_EXPORT DVect3 getDir(unsigned int dof) const;
    BASE_EXPORT void   setDir(unsigned int dof,const DVect3 &v);
    BASE_EXPORT void   setDirAuto(unsigned int dof,unsigned int keepDOF=0xFFFFFFFF);
    BASE_EXPORT Orientation3 getOrientation(unsigned int dof=0) const;
    BASE_EXPORT Double getRoll() const;

    // Static
    static BASE_EXPORT Axes3D make(const DVect3 &z,const Double &roll=0.0);
    static BASE_EXPORT Axes3D makeX(const DVect3 &x,const Double &roll=0.0);
    static BASE_EXPORT Axes3D make(const Orientation3 &o,const Double &roll=0.0);
    static BASE_EXPORT Axes3D makeX(const Orientation3 &o,const Double &roll=0.0);
    static BASE_EXPORT Axes3D make(const DVect3 &z,const DVect3 &x);
    // Makes a default axes assuming dir only is specified.
    static BASE_EXPORT Axes3D make(const DVect3 &dir,unsigned dof);
    static BASE_EXPORT Axes3D makeDef() { Axes3D a(DVect3(1,0,0),DVect3(0,1,0),DVect3(0,0,1));  return a; }
    static BASE_EXPORT void setTolerance(const double &d); // Defaults to 1e-6
    static BASE_EXPORT double getTolerance();
    static BASE_EXPORT Axes3D global() { return Axes3D(DVect3(1,0,0),DVect3(0,1,0),DVect3(0,0,1)); }
private:
    DVect3 c_;
    DVect3 d1_;
    DVect3 d2_;
    DVect3 d3_;
};

// EOF