Vec3.h

Go to the documentation of this file.

// $Id$
//==============================================================================
//==============================================================================
 
#ifndef _VEC3_H
#define _VEC3_H
 
#include <vector>
#include <iostream>
#include <cmath>
 
 
class Vec3
{
  Real v[3]; 
 
public:
  Real& x; 
  Real& y; 
  Real& z; 
 
  Vec3() : x(v[0]), y(v[1]), z(v[2]) { x = y = z = Real(0); }
  Vec3(Real X, Real Y, Real Z = Real(0)) : x(v[0]), y(v[1]), z(v[2])
  { x = X; y = Y; z = Z; }
  Vec3(const Real* pos, size_t n = 3) : x(v[0]), y(v[1]), z(v[2])
  { for (size_t i = 0; i < 3; i++) v[i] = i < n ? pos[i] : Real(0); }
  Vec3(const std::vector<Real>& X) : x(v[0]), y(v[1]), z(v[2])
  { for (size_t i = 0; i < 3; i++) v[i] = i < X.size() ? X[i] : Real(0); }
  Vec3(const Vec3& X) : x(v[0]), y(v[1]), z(v[2])
  { x = X.x; y = X.y; z = X.z; }
  Vec3(const Vec3& X, const Vec3& Y) : x(v[0]), y(v[1]), z(v[2])
  { this->cross(X,Y); }
 
  virtual ~Vec3() {}
 
  Vec3& operator=(const Vec3& X) { x = X.x; y = X.y; z = X.z; return *this; }
  Vec3& operator=(Real val) { x = y = z = val; return *this; }
 
  const Real& operator()(int i) const { return v[i-1]; }
  const Real& operator[](int i) const { return v[i]; }
  Real& operator()(int i) { return v[i-1]; }
  Real& operator[](int i) { return v[i]; }
 
  const Real* ptr() const { return v; }
 
  std::vector<Real> vec(size_t n = 3) const
  { return std::vector<Real>(v, v + (n < 3 ? n : 3)); }
 
  Vec3& operator*=(Real c) { x *= c; y *= c; z *= c; return *this; }
  Vec3& operator/=(Real d) { x /= d; y /= d; z /= d; return *this; }
 
  Vec3& operator+=(const Vec3& X)
  {
    x += X.x;
    y += X.y;
    z += X.z;
    return *this;
  }
 
  Vec3& operator-=(const Vec3& X)
  {
    x -= X.x;
    y -= X.y;
    z -= X.z;
    return *this;
  }
 
  Vec3 operator-() const { return Vec3(-x,-y,-z); }
 
  Real sum() const { return x+y+z; }
  Real asum() const { return std::fabs(x) + std::fabs(y) + std::fabs(z); }
 
  Real length2() const { return x*x+y*y+z*z; }
 
  double length() const { return sqrt(this->length2()); }
 
  Real normalize(double tol = 1.0e-16)
  {
    double len = this->length();
    if (len <= tol) return len;
    x /= len; y /= len; z /= len;
    return len;
  }
 
  Vec3& cross(const Vec3& a, const Vec3& b)
  {
    x = a.y*b.z - a.z*b.y;
    y = a.z*b.x - a.x*b.z;
    z = a.x*b.y - a.y*b.x;
    return *this;
  }
 
  bool equal(const Vec3& a, double tol = 1.0e-6) const
  {
    if (fabs(x-a.x) <= tol)
      if (fabs(y-a.y) <= tol)
        if (fabs(z-a.z) <= tol)
          return true;
 
    return false;
  }
 
  bool isZero(double tol = 1.0e-6) const
  {
    if (fabs(x) <= tol)
      if (fabs(y) <= tol)
        if (fabs(z) <= tol)
          return true;
 
    return false;
  }
 
  bool lessThan(const Vec3& a, double tol = 1.0e-6) const
  {
    for (int i = 2; i >= 0; i--)
      if (v[i]+tol < a.v[i])
        return true;
      else if (v[i]-tol > a.v[i])
        return false;
 
    return false;
  }
 
  bool inside(const Vec3& a, const Vec3& b, double tol = 1.0e-6) const
  {
    for (int i = 0; i < 3; i++)
      if (v[i]+tol < a.v[i] || v[i]-tol > b.v[i])
        return false;
 
    return true;
  }
 
  virtual std::ostream& print(std::ostream& os, double tol = 1.0e-12) const
  {
    if (fabs(x) > tol)
      os << x;
    else
      os <<"0";
 
    if (fabs(y) > tol)
      os <<" "<< y;
    else
      os <<" 0";
 
    if (fabs(z) > tol)
      os <<" "<< z;
    else
      os <<" 0";
 
    return os;
  }
 
  static double comparisonTolerance; 
};
 
 
class Vec4 : public Vec3
{
public:
  const Real* u; 
 
  Real t;   
  int  idx; 
 
  explicit Vec4(const Real* par = nullptr, Real T = Real(0))
  {
    u = par;
    t = T;
    idx = -1;
  }
 
  explicit Vec4(Real T)
  {
    u = nullptr;
    t = T;
    idx = -1;
  }
 
  Vec4(Real X, Real Y, Real Z, Real T = Real(0)) : Vec3(X,Y,Z)
  {
    u = nullptr;
    t = T;
    idx = -1;
  }
 
  Vec4(const Vec3& X, Real T = Real(0), int id = -1) : Vec3(X)
  {
    u = nullptr;
    t = T;
    idx = id;
  }
 
  Vec4(const Vec3& X, Real T, const Real* par) : Vec3(X)
  {
    u = par;
    t = T;
    idx = -1;
  }
 
  Vec4(const std::vector<Real>& X, const Real* par = nullptr) : Vec3(X)
  {
    u = par;
    t = X.size() > 3 ? X[3] : Real(0);
    idx = -1;
  }
 
  Vec4(const Vec4& X) : Vec3(X)
  {
    u = X.u;
    t = X.t;
    idx = X.idx;
  }
 
  Vec4& operator=(const Vec4& X)
  {
    x = X.x;
    y = X.y;
    z = X.z;
    t = X.t;
    idx = X.idx;
    u = X.u;
 
    return *this;
  }
 
  Vec4& operator=(Real val) { x = y = z = val; return *this; }
 
  Vec4& assign(const Vec3& X)
  {
    const Vec4* x4 = dynamic_cast<const Vec4*>(&X);
    if (x4)
      this->operator=(*x4);
    else
    {
      x = X.x;
      y = X.y;
      z = X.z;
    }
 
    return *this;
  }
 
  std::ostream& print(std::ostream& os, double tol = 1.0e-12) const override
  {
    if (idx >= 0) os <<"(idx="<< idx <<") ";
    this->Vec3::print(os,tol);
    if (u) os <<" ("<< u[0] <<" "<< u[1] <<" "<< u[2] <<")";
    if (t > Real(0)) os <<" "<< t;
    return os;
  }
};
 
 
using Vec3Pair    = std::pair<Vec3,Vec3>;    
using PointValue  = std::pair<Vec3,Real>;    
using Vec3Vec     = std::vector<Vec3>;       
using PointValues = std::vector<PointValue>; 
 
#endif