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