axes.h

Go to the documentation of this file.

#pragma once
 
#include "vect.h"
#include "avect.h"
#include "orientation.h"
 
 
class Axes2D {
public:
    constexpr Axes2D()=default;
    constexpr Axes2D(const Axes2D &a)=default;
    constexpr Axes2D &operator=(const Axes2D &a)=default;
 
    BASE_EXPORT Axes2D(const DVect2 &vx,const DVect2 &vy,bool normalize,const DVect2 &c=DVect2(0));
    BASE_EXPORT explicit Axes2D(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 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(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(uint32 dof) const;
    BASE_EXPORT void   setDir(uint32 dof,const DVect2 &v);
    BASE_EXPORT void   setDirAuto(uint32 dof,uint32 keepDOF=0xFFFFFFFF);
    BASE_EXPORT Orientation2 getOrientation(uint32 dof=0) const;
 
    // Static
    static BASE_EXPORT Axes2D make(const DVect2 &y,bool normalize);
    static BASE_EXPORT Axes2D makeX(const DVect2 &x,bool normalize);
    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,uint32 dof,bool normalize);
    static BASE_EXPORT Axes2D makeDef() { Axes2D a(DVect2(1,0),DVect2(0,1),false);  return a; }
    static BASE_EXPORT void setTolerance(double d);
    static BASE_EXPORT double getTolerance();
    static BASE_EXPORT Axes2D global() { return Axes2D(DVect2(1,0),DVect2(0,1),false); }
private:
    DVect2 c_  = DVect2(0.0, 0.0);
    DVect2 d1_ = DVect2(1.0, 0.0);
    DVect2 d2_ = DVect2(0.0, 1.0);
};
 
 
 
 
class Axes3D {
public:
    constexpr Axes3D()=default;
    constexpr Axes3D(const Axes3D &a)=default;
    constexpr Axes3D &operator=(const Axes3D &a)=default;
 
    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, bool normalize,const DVect3 &c=DVect3(0));
    BASE_EXPORT Axes3D(double dip,double ddir,double roll=0.0, const DVect3 &c=DVect3(0)) { setOrientation(dip,ddir,roll); setOrigin(c); }
    BASE_EXPORT explicit Axes3D(const Orientation3 &o,double roll=0.0,const DVect3 &c=DVect3(0)) { setOrientation(o,roll); setOrigin(c); }
 
    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(double dip,double ddir,double roll);  // radians
    BASE_EXPORT void setOrientation(const Orientation3 &o,double roll);
 
    // 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(uint32 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(uint32 dof) const;
    BASE_EXPORT void   setDir(uint32 dof,const DVect3 &v);
    BASE_EXPORT void   setDirAuto(uint32 dof,uint32 keepDOF=0xFFFFFFFF);
    BASE_EXPORT Orientation3 getOrientation(uint32 dof=0) const;
    BASE_EXPORT double getRoll() const;
 
    // Static
    static BASE_EXPORT Axes3D make(const DVect3 &z,bool normalize,double roll=0.0);
    static BASE_EXPORT Axes3D makeX(const DVect3 &x,bool normalize,double roll=0.0);
    static BASE_EXPORT Axes3D make(const Orientation3 &o,double roll=0.0);
    static BASE_EXPORT Axes3D makeX(const Orientation3 &o,double roll=0.0);
    static BASE_EXPORT Axes3D make(const DVect3 &z,const DVect3 &x,bool normalize);
    // Makes a default axes assuming dir only is specified.
    static BASE_EXPORT Axes3D make(const DVect3 &dir,uint32 dof,bool normalize);
    static BASE_EXPORT Axes3D makeDef() { Axes3D a(DVect3(1,0,0),DVect3(0,1,0),DVect3(0,0,1),false);  return a; }
    static BASE_EXPORT void setTolerance(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),false); }
private:
    DVect3 c_  = DVect3(0.0, 0.0, 0.0);
    DVect3 d1_ = DVect3(1.0, 0.0, 0.0);
    DVect3 d2_ = DVect3(0.0, 1.0, 0.0);
    DVect3 d3_ = DVect3(0.0, 0.0, 1.0);
};
 
// EOF