orientation.h

Go to the documentation of this file.

#pragma once
#include "vect.h"
 
#ifndef _PI_DEFINED
#define _PI_DEFINED
static constexpr double dPi = 3.141592653589793238462643383279502884197169399;
#endif
static constexpr double dDegrad = 0.01745329251994329576923690768488; // pi/180
static constexpr double cosSmallDeg = 9.999999998476913e-01; // cosine of 0.001 degrees
static constexpr double cosHalfDeg = 9.999619230641713e-01; // cosine of 0.5 degrees
static constexpr double cosOneDeg = 9.998476951563913e-01; // cosine of 1 degree
static constexpr double cosTwoDeg = 9.993908270190958e-01; // cosine of 2 degrees
static constexpr double cosFiveDeg = 9.961946980917455e-01; // cosine of 5 degrees
 
class Orientation2 {
public:
 BASE_EXPORT Orientation2() : normal_(0.0,1.0), normalUser_(0,1.0), definedByNormal_(true) { }
 BASE_EXPORT explicit Orientation2(const DVect2 &dv2) : normal_(dv2.unit()), normalUser_(dv2) { }
 BASE_EXPORT explicit Orientation2(const double &dip) : normal_(getNormFromDip(dip)), normalUser_(getNormFromDip(dip)) { }
 BASE_EXPORT bool operator==(const Orientation2 &o) const { return (normal_==o.normal_); }
 BASE_EXPORT bool operator!=(const Orientation2 &o) const { return !operator==(o); }
 
 BASE_EXPORT const DVect2 &getNormal() const { return normal_; }
 BASE_EXPORT const DVect2 &getNormalUser() const { return normalUser_; }
 BASE_EXPORT double getDip() const { return getDipFromNorm(normal_); }
 BASE_EXPORT bool wasDefinedByNormal() const { return definedByNormal_; }
 BASE_EXPORT double getJointAngle() const { return getJointAngleFromNorm(normal_); }
 
 BASE_EXPORT void setNormal(const DVect2 &norm) { normal_ = norm.unit(); normalUser_ = norm; definedByNormal_ = true; }
 BASE_EXPORT void setDip(const double &dip) { normalUser_ = normal_ = getNormFromDip(dip); definedByNormal_ = false; }
 BASE_EXPORT void setJointAngle(const double &ja) { normalUser_ = normal_ = getNormFromJointAngle(ja); }
 
 static BASE_EXPORT DVect2 getNormFromDip(const double &dip);
 static BASE_EXPORT double getDipFromNorm(const DVect2 &norm);
 static BASE_EXPORT DVect2 getNormFromJointAngle(const double &ja);
 static BASE_EXPORT double getJointAngleFromNorm(const DVect2 &norm);
 
private:
 DVect2 normal_;
 DVect2 normalUser_;
 bool definedByNormal_ = false;
};
 
class Orientation3 {
public:
 BASE_EXPORT Orientation3();
 BASE_EXPORT Orientation3(const Orientation3 &o);
 BASE_EXPORT explicit Orientation3(const DVect3 &dv3);
 BASE_EXPORT explicit Orientation3(const double &dip,const double &dd=0.0);
 BASE_EXPORT const Orientation3 &operator=(const Orientation3 &o);
 BASE_EXPORT bool operator==(const Orientation3 &o) const { return(normal_==o.normal_); }
 BASE_EXPORT bool operator!=(const Orientation3 &o) const { return !operator==(o); }
 
 BASE_EXPORT const DVect3 &getNormal() const { return(normal_); }
 BASE_EXPORT const DVect3 &getNormalUser() const { return(normalUser_); }
 BASE_EXPORT DVect2 getDipDD() const { return(dipdd_); }
 BASE_EXPORT double getDip() const { return(dipdd_.x()); }
 BASE_EXPORT double getDipDirection() const { return(dipdd_.y()); }
 BASE_EXPORT bool wasDefinedByNormal() const { return(definedByNormal_); }
 BASE_EXPORT double getJointAngle() const { return getJointAngleFromNorm(normal_); }
 BASE_EXPORT double getAzimuth() const { return getAzimuthFromNorm(normal_); }
 BASE_EXPORT double getPlunge() const { return getPlungeFromNorm(normal_); }
 
 BASE_EXPORT void setNormal(const DVect3 &norm);
 BASE_EXPORT void setNormalX(const double &x);
 BASE_EXPORT void setNormalY(const double &y);
 BASE_EXPORT void setNormalZ(const double &z);
 BASE_EXPORT void setDipDD(const double &dip,const double &dd);
 BASE_EXPORT void setDip(const double &dip);
 BASE_EXPORT void setDipDirection(const double &dd);
 BASE_EXPORT void setJointAngle(const double &angle);
 BASE_EXPORT void setAzimuthPlunge(const double &azimuth,const double &plunge);
 BASE_EXPORT bool isIn(const DVect3 &normal,const DVect2 &tol) const;
 
 // Handy dip/dd to normal 3D conversion routines.
 static BASE_EXPORT DVect3 getNormFromDipDD(const double &dip,const double &dd);
 static BASE_EXPORT DVect3 getVectorFromAzimuthPlunge(const double &az,const double &plunge);
 // Handy dip/dd to normal 3D conversion routines.
 static BASE_EXPORT DVect3 getNormFromAzimuthPlunge(const double &azimuth,const double &plunge);
 static BASE_EXPORT DVect2 getDipDDFromNorm(const DVect3 &norm);
 static BASE_EXPORT double getJointAngleFromNorm(const DVect3 &norm);
 static BASE_EXPORT double getAzimuthFromNorm(const DVect3 &norm);
 static BASE_EXPORT double getPlungeFromNorm(const DVect3 &norm);
 static BASE_EXPORT bool getLHS() { return lhs_; }
 static BASE_EXPORT void setLHS(bool b) { lhs_ = b; } 
 
private:
 DVect3 normal_;
 DVect3 normalUser_;
 DVect2 dipdd_;
 bool definedByNormal_ = false;
 BASE_EXPORT static bool lhs_;
};
 
// EOF