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,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 constexpr 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(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:
 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, 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 constexpr 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(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