MbVec3.h

/*=======================================================================
 *** THE CONTENT OF THIS WORK IS PROPRIETARY TO FEI S.A.S, (FEI S.A.S.),            ***
 ***              AND IS DISTRIBUTED UNDER A LICENSE AGREEMENT.                     ***
 ***                                                                                ***
 ***  REPRODUCTION, DISCLOSURE,  OR USE,  IN WHOLE OR IN PART,  OTHER THAN AS       ***
 ***  SPECIFIED  IN THE LICENSE ARE  NOT TO BE  UNDERTAKEN  EXCEPT WITH PRIOR       ***
 ***  WRITTEN AUTHORIZATION OF FEI S.A.S.                                           ***
 ***                                                                                ***
 ***                        RESTRICTED RIGHTS LEGEND                                ***
 ***  USE, DUPLICATION, OR DISCLOSURE BY THE GOVERNMENT OF THE CONTENT OF THIS      ***
 ***  WORK OR RELATED DOCUMENTATION IS SUBJECT TO RESTRICTIONS AS SET FORTH IN      ***
 ***  SUBPARAGRAPH (C)(1) OF THE COMMERCIAL COMPUTER SOFTWARE RESTRICTED RIGHT      ***
 ***  CLAUSE  AT FAR 52.227-19  OR SUBPARAGRAPH  (C)(1)(II)  OF  THE RIGHTS IN      ***
 ***  TECHNICAL DATA AND COMPUTER SOFTWARE CLAUSE AT DFARS 52.227-7013.             ***
 ***                                                                                ***
 ***                   COPYRIGHT (C) 1996-2017 BY FEI S.A.S,                        ***
 ***                        BORDEAUX, FRANCE                                        ***
 ***                      ALL RIGHTS RESERVED                                       ***
**=======================================================================*/
/*=======================================================================
** Author      : VSG (MMM YYYY)
**=======================================================================*/
#ifndef  _MBVEC3_H
#define  _MBVEC3_H
 
#ifdef _WIN32
#  pragma warning( push )
#  pragma warning(disable:4250)
#endif
 
 
#include <Inventor/STL/iostream>
#include <Inventor/STL/limits>
#include <Inventor/SbMathHelper.h>
 
#include <cmath>
 
template <typename _T>
class MbVec3
{
public:
  typedef _T ValueType;
 
  static MbVec3 numeric_limit_max()
  {
    return MbVec3<_T>((std::numeric_limits<_T>::max)());
  }
 
  MbVec3() 
  { 
    vec[0] = vec[1] = vec[2] = 0; 
  }
  MbVec3(const _T v[3])
  { 
    vec[0] = v[0]; vec[1] = v[1]; vec[2] = v[2]; 
  }
 
  MbVec3(_T x, _T y, _T z)
  { 
    vec[0] = x; vec[1] = y; vec[2] = z; 
  }
 
  template < typename _Type >
  MbVec3(_Type x, _Type y, _Type z)
  { 
    vec[0] = (_T) x; vec[1] = (_T) y; vec[2] = (_T) z; 
  }
 
  explicit MbVec3(char v)
  { 
    vec[0] = (_T)v; vec[1] = (_T)v; vec[2] = (_T)v; 
  }
 
  explicit MbVec3(unsigned char v)
  { 
    vec[0] = (_T)v; vec[1] = (_T)v; vec[2] = (_T)v; 
  }
 
  explicit MbVec3(short v)
  { 
    vec[0] = (_T)v; vec[1] = (_T)v; vec[2] = (_T)v; 
  }
 
  explicit MbVec3(unsigned short v)
  { 
    vec[0] = (_T)v; vec[1] = (_T)v; vec[2] = (_T)v; 
  }
 
  explicit MbVec3(int v)
  { 
    vec[0] = (_T)v; vec[1] = (_T)v; vec[2] = (_T)v; 
  }
 
  explicit MbVec3(size_t v)
  { 
    vec[0] = (_T)v; vec[1] = (_T)v; vec[2] = (_T)v; 
  }
 
  explicit MbVec3(long v)
  { 
    vec[0] = (_T)v; vec[1] = (_T)v; vec[2] = (_T)v; 
  }
 
#if defined(_WIN32)
  explicit MbVec3(unsigned long v)
  { 
    vec[0] = (_T)v; vec[1] = (_T)v; vec[2] = (_T)v; 
  }
#endif
 
  explicit MbVec3(float v)
  { 
    vec[0] = (_T)v; vec[1] = (_T)v; vec[2] = (_T)v; 
  }
 
  explicit MbVec3(double v)
  { 
    vec[0] = (_T)v; vec[1] = (_T)v; vec[2] = (_T)v; 
  }
 
  explicit MbVec3(long double v)
  { 
    vec[0] = (_T)v; vec[1] = (_T)v; vec[2] = (_T)v; 
  }
 
  template<typename _MbVec3T>
  explicit MbVec3(const _MbVec3T& v)
  {
    vec[0] = (_T)v[0];
    vec[1] = (_T)v[1];
    vec[2] = (_T)v[2];
  }
 
  MbVec3  cross(const MbVec3<_T> &v) const
  {
    return MbVec3<_T>(vec[1] * v.vec[2] - vec[2] * v.vec[1],
      vec[2] * v.vec[0] - vec[0] * v.vec[2],
      vec[0] * v.vec[1] - vec[1] * v.vec[0]);
  }
 
  _T  dot(const MbVec3<_T> &v) const 
  {
    return (vec[0] * v.vec[0] + vec[1] * v.vec[1] + vec[2] * v.vec[2]);
  }
 
  const _T *getValue() const { return vec; }
 
  void getValue(_T &x, _T &y, _T &z) const
  {
    x = vec[0]; y = vec[1]; z = vec[2];
  }
 
  _T length() const
  {
    return _T(sqrt(double(vec[0] * vec[0] + vec[1] * vec[1] + vec[2] * vec[2])));
  }
 
  _T  normalize();
 
  void  negate()
  {
    vec[0] = -vec[0]; vec[1] = -vec[1]; vec[2] = -vec[2];
  }
 
  MbVec3 mult(const MbVec3<_T> &v) const 
  {
    return MbVec3<_T>(vec[0] * v.vec[0], vec[1] * v.vec[1],vec[2] * v.vec[2]) ;
  }
 
  MbVec3 div(const MbVec3<_T> &v) const 
  {
    return MbVec3<_T>(vec[0] / v.vec[0], vec[1] / v.vec[1],vec[2] / v.vec[2]) ;
  }
 
  MbVec3<_T>& setValue(const _T v[3])
  { 
    vec[0] = v[0]; vec[1] = v[1]; vec[2] = v[2]; return *this; 
  }
 
  MbVec3<_T> &setValue(_T x, _T y, _T z)
  { 
    vec[0] = x; vec[1] = y; vec[2] = z; return *this; 
  }
 
 
  _T& operator [](int i) { return (vec[i]); }
  const _T & operator [](int i) const  { return (vec[i]); }
  _T& operator [](size_t i) { return (vec[i]); }
  const _T & operator [](size_t i) const  { return (vec[i]); }
 
  MbVec3 & operator =(_T d)
  {
    vec[0] = vec[1] = vec[2] = d;
    return *this;
  }
 
  MbVec3 & operator *=(_T d)
  {
    vec[0] *= d;
    vec[1] *= d;
    vec[2] *= d;
    return *this;
  }
 
  MbVec3 & operator /=(_T d)
  { 
    vec[0] /= d;
    vec[1] /= d;
    vec[2] /= d;
    return *this; 
  }
 
  MbVec3 & operator +=(const MbVec3 &v)
  {
    vec[0] += v.vec[0];
    vec[1] += v.vec[1];
    vec[2] += v.vec[2];
    return *this;
  }
 
  MbVec3 & operator -=(const MbVec3 &v)
  {
    vec[0] -= v.vec[0];
    vec[1] -= v.vec[1];
    vec[2] -= v.vec[2];
    return *this;
  }
 
 
  MbVec3 operator -() const
  {
    return MbVec3<_T>(-vec[0],-vec[1],-vec[2]);
  }
 
  friend MbVec3 operator *(const MbVec3 &v1, const MbVec3 &v2)
  {
    return MbVec3(v1.vec[0] * v2.vec[0], v1.vec[1] * v2.vec[1], v1.vec[2] * v2.vec[2]);
  }
 
  friend MbVec3 operator *(const MbVec3 &v, _T d)
  {
    return MbVec3<_T>(v.vec[0] * d, v.vec[1] * d, v.vec[2] * d);
  }
 
  friend MbVec3 operator *(_T d, const MbVec3 &v)
  { return v * d; }
 
  friend MbVec3 operator /(const MbVec3 &v, _T d)
  { 
    return MbVec3<_T>(v.vec[0] / d, v.vec[1] / d, v.vec[2] / d);
  }
 
  friend MbVec3 operator /(const MbVec3 &v1, const MbVec3 &v2)
  {
    return MbVec3(v1.vec[0] / v2.vec[0], v1.vec[1] / v2.vec[1], v1.vec[2] / v2.vec[2]);
  }
 
  friend MbVec3 operator +(const MbVec3 &v1, const MbVec3 &v2)
  {
    return MbVec3(v1.vec[0] + v2.vec[0], v1.vec[1] + v2.vec[1], v1.vec[2] + v2.vec[2]);
  }
 
  friend MbVec3 operator +(const MbVec3 &v, _T d)
  {
    return MbVec3(v.vec[0] + d, v.vec[1] + d, v.vec[2] + d);
  }
 
  friend MbVec3 operator +(_T d, const MbVec3 &v)
  {
    return MbVec3(v.vec[0] + d, v.vec[1] + d, v.vec[2] + d);
  }
 
  friend MbVec3 operator -(const MbVec3 &v1, const MbVec3 &v2)
  {
    return MbVec3(v1.vec[0] - v2.vec[0], v1.vec[1] - v2.vec[1], v1.vec[2] - v2.vec[2]);
  }
 
  friend MbVec3 operator -(const MbVec3 &v, _T d)
  {
    return MbVec3(v.vec[0] - d, v.vec[1] - d, v.vec[2] - d);
  }
 
  friend MbVec3 sqrt(const MbVec3 &v)
  {
    return MbVec3(sqrt(v.vec[0]), sqrt(v.vec[1]), sqrt(v.vec[2]));
  }
 
  friend bool operator ==(const MbVec3 &v1, const MbVec3 &v2)
  {
    return (v1.vec[0] == v2.vec[0] && v1.vec[1] == v2.vec[1] && v1.vec[2] == v2.vec[2]);
  }
 
  friend bool operator !=(const MbVec3 &v1, const MbVec3 &v2)
  { 
    return !(v1 == v2); 
  }
 
  friend bool operator <(const MbVec3 &v1, const MbVec3 &v2)
  { 
    return v1.length() < v2.length(); 
  }
 
  friend bool operator <=(const MbVec3 &v1, const MbVec3 &v2)
  { 
    return v1.length() <= v2.length(); 
  }
 
  friend bool operator >(const MbVec3 &v1, const MbVec3 &v2)
  { 
    return v1.length() > v2.length(); 
  }
 
  friend bool operator >=(const MbVec3 &v1, const MbVec3 &v2)
  { 
    return v1.length() >= v2.length(); 
  }
 
  bool equals(const MbVec3 &v, _T tolerance) const
  {
    MbVec3  diff = *this - v;
    return diff.dot(diff) <= tolerance;
  }
 
  bool equals(const MbVec3 &v) const
  {
    return this->equals(v,std::numeric_limits<_T>::epsilon());
  }
 
  friend bool areCollinear(const MbVec3<_T> &v1, const MbVec3<_T> &v2, _T tol) 
  {
    return SbMathHelper::isCoinc(v1[0]*v2[1],v1[1]*v2[0],tol) && SbMathHelper::isCoinc(v1[0]*v2[2],v1[2]*v2[0],tol)
        && SbMathHelper::isCoinc(v1[1]*v2[2],v1[2]*v2[1],tol);
  }
 
  friend bool areCollinear(const MbVec3<_T> &v1, const MbVec3<_T> &v2) 
  {
    return areCollinear(v1,v2,std::numeric_limits<_T>::epsilon());
  }
 
  friend inline std::ostream& operator << (std::ostream& os, const MbVec3& v)
  {
    return os << "(" << v.vec[0] << "," << v.vec[1] << "," << v.vec[2] << ")";
  }
 
private:
  _T vec[3];
};
 
template <typename _T>
_T  
MbVec3<_T>::normalize()
{
  _T len = length();
 
  if (len != 0)
    (*this) /= len;
  else
    setValue(0,0,0);
  return len;
}
 
typedef MbVec3<size_t> MbVec3ui;
 
typedef MbVec3<float> MbVec3f;
typedef MbVec3<double> MbVec3d;
 
#ifdef _WIN32
#  pragma warning( pop )
#endif
 
#endif