AnimaL

Tutorial

Documentation

---

Documentation

• Overview
• Modules
• Namespace List
• Class Hierarchy
• Alphabetical List
• Compound List
• File List
• Namespace Members
• Compound Members
• File Members
• Examples

---

Vec3.h

Go to the documentation of this file.

#ifndef Vec3_H
#define Vec3_H

#include <math.h>
#include <iostream>
#include <stdexcept>


//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Interface of Vec3 DataType
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
namespace animal {
namespace octree {

template<class DataType>
struct Vec3
{
  // The first coordinate of the point
  DataType x;
  // The second coordinate of the point
  DataType y;
  // The third coordinate of the point
  DataType z;
  
  
  inline Vec3();
  inline Vec3(const DataType x,const DataType y,const DataType z);
  inline Vec3(const Vec3& v);
    
    
  inline void set(const DataType x,const DataType y,const DataType z);
  inline void set(const Vec3& v);
    
  inline operator const DataType*() const;

    
  inline bool operator==(const Vec3& b) const;
  inline bool operator!=(const Vec3& b) const;
  inline bool operator<(const Vec3& b) const;
  inline const DataType& operator[](const int i) const;
  inline DataType& operator[](const int i);
  
  inline Vec3& operator+=(const Vec3& a);
  inline Vec3& operator-=(const Vec3& a);
  inline Vec3& operator*=(const DataType& k);
  inline Vec3& operator/=(const DataType& k);

  inline DataType norm2() const;
  inline DataType norm() const;
  inline void normalize();
  inline Vec3 normalized() const;
  inline Vec3 normalized(DataType& f) const;
  inline Vec3 withX(const DataType theX) const;
  inline Vec3 withY(const DataType theY) const;
  inline Vec3 withZ(const DataType theZ) const;
  inline Vec3 nonColinearVec() const;

  inline Vec3 get_Vec3() { return *this; };
  
  
  // Addition between Vec3
  inline Vec3 operator+( const Vec3<DataType>& a ) const;
  
  // Soustraction between Vec3
  inline Vec3 operator-( const Vec3<DataType>& a ) const;
  
  // Minus operator
  inline Vec3 operator-() const;

  // Left and Right products with a DataType  
  inline Vec3 operator*( const DataType k ) const;
  friend Vec3 operator*( const DataType k, const Vec3<DataType>& v )
  {
    return v * k;
  };
  
  // Division with a DataType
  inline Vec3 operator/( const DataType k ) const;
  
  // Dot and inner product
  inline DataType operator*( const Vec3<DataType>& a ) const;
  inline Vec3 operator^( const Vec3<DataType>& a ) const;
  
  // Stream operations  
  friend std::ostream& operator<<(std::ostream& s, const Vec3<DataType>& v )
  {
    s<<"("<<v.x<<","<<v.y<<","<<v.z<<")";
    return s;
  };
  
  friend std::istream& operator>>(std::istream& s, Vec3<DataType>& v )
  {
    char c;
    s.get(c);
    s>>v.x;
    s.get(c);
    s>>v.y;
    s.get(c);
    s>>v.z;
    s.get(c);
    return s;  
  };


  static inline const Vec3& axis(const int i);

  
};


//************************************************************
// Implementation of Vec3
//************************************************************
template<class DataType>
inline
Vec3<DataType>::Vec3()
  : x(0.0f), y(0.0f), z(0.0f)
{
}
 template<class DataType>
inline Vec3<DataType>::Vec3(const DataType x,const DataType y,const DataType z)
  : x(x), y(y), z(z)
{
}
 template<class DataType>
inline Vec3<DataType>::Vec3(const Vec3& v)
  : x(v[0]),y(v[1]),z(v[2])
{
}
/*
inline Vec3<DataType>::Vec3( const animal::VectorVec<DataType>& v )
    : x(v[0]),y(v[1]),z(v[2])
{
}
*/


 template<class DataType>
inline void
Vec3<DataType>::set(const DataType ax,const DataType ay,const DataType az)
{
  x = ax;
  y = ay;
  z = az;
}
template<class DataType>
inline void Vec3<DataType>::set(const Vec3& v)
{
    this->set( v[0], v[1], v[2] );
}

 template<class DataType>
inline Vec3<DataType>::operator const DataType*() const
{
  return static_cast<const DataType*>(&x);
}



 template<class DataType>
inline bool
Vec3<DataType>::operator==(const Vec3& b) const
{
  return (x == b.x &&
      y == b.y &&
      z == b.z);
}
 template<class DataType>
inline bool
Vec3<DataType>::operator!=(const Vec3& b) const
{
  return (x != b.x ||
      y != b.y ||
      z != b.z);
}
 template<class DataType>
inline bool
Vec3<DataType>::operator<(const Vec3& b) const
{
  return ((x < b.x) ||
      ((x == b.x) && y < b.y) ||
      ((x == b.x  && y == b.y) && z < b.z));
}
 template<class DataType>
inline const DataType&
Vec3<DataType>::operator[](const int i) const
{
  return static_cast<const DataType*>(&x)[i] ;
}
 template<class DataType>
inline DataType&
Vec3<DataType>::operator[](const int i)
{
  return static_cast<DataType*>(&x)[i] ;
}





template<class DataType>
inline Vec3<DataType>& Vec3<DataType>::operator*=(const DataType& k)
{
    this->x *= k;
    this->y *= k;
    this->z *= k;
    return *this;
}
template<class DataType>
inline Vec3<DataType>& Vec3<DataType>::operator/=(const DataType& k)
{
    this->x /= k;
    this->y /= k;
    this->z /= k;
    return *this;
}

template<class DataType>
inline Vec3<DataType>& Vec3<DataType>::operator+=(const Vec3& a)
{
    this->x += a.x;
    this->y += a.y;
    this->z += a.z;
    return *this;
}
template<class DataType>
inline Vec3<DataType>& Vec3<DataType>::operator-=(const Vec3& a)
{
    this->x -= a.x;
    this->y -= a.y;
    this->z -= a.z;
    return *this;
}


template<class DataType>
Vec3<DataType> Vec3<DataType>::operator+( const Vec3<DataType>&  v ) const
{
    return Vec3<DataType>( x+v.x, y+v.y, z+v.z );
}

template<class DataType>
Vec3<DataType> Vec3<DataType>::operator-( const Vec3<DataType>& v ) const
{
    return Vec3<DataType>( x-v.x, y-v.y, z-v.z );
}

template<class DataType>
Vec3<DataType> Vec3<DataType>::operator-( ) const
{
    return Vec3<DataType>( -x, -y, -z );
}




template<class DataType>
DataType Vec3<DataType>::operator*( const Vec3<DataType>& v ) const
{
    return x*v.x + y*v.y + z*v.z;
}
template<class DataType>
Vec3<DataType> Vec3<DataType>::operator*( const DataType k ) const
{
    return Vec3<DataType>( x*k, y*k, z*k );
}
  
template<class DataType>
Vec3<DataType> Vec3<DataType>::operator/( const DataType k ) const
{
    return Vec3<DataType>( x/k, y/k, z/k );
}  

template<class DataType>
Vec3<DataType> Vec3<DataType>::operator^( const Vec3<DataType>& v ) const
{
  return Vec3<DataType>(y*v.z - z*v.y,
          z*v.x - x*v.z,
          x*v.y - y*v.x);
}



 template<class DataType>
inline DataType
Vec3<DataType>::norm2() const
{
  return x*x+y*y+z*z;
}
 template<class DataType>
inline DataType
Vec3<DataType>::norm() const
{
  return sqrtf(norm2()) ;
}
 template<class DataType>
inline void
Vec3<DataType>::normalize()
{
  const DataType f = norm();
  x /= f ;
  y /= f ;
  z /= f ;
}

 template<class DataType>
inline Vec3<DataType>
Vec3<DataType>::normalized() const
{
  return *this / norm() ;
}
 template<class DataType>
inline Vec3<DataType>
Vec3<DataType>::normalized(DataType& l) const
{
  return *this / (l=norm()) ;
}
 template<class DataType>
inline Vec3<DataType>
Vec3<DataType>::withX(const DataType theX) const
{
  return Vec3(theX,y,z);
}
 template<class DataType>
inline Vec3<DataType>
Vec3<DataType>::withY(const DataType theY) const
{
  return Vec3(x,theY,z);
}
 template<class DataType>
inline Vec3<DataType>
Vec3<DataType>::withZ(const DataType theZ) const
{
  return Vec3(x,y,theZ);
}

template<class DataType>
inline const Vec3<DataType>&
Vec3<DataType>::axis(const int i)
{
  static const Vec3 axis[3] =
    {
      Vec3(1.0f,0.0f,0.0f),
      Vec3(0.0f,1.0f,0.0f),
      Vec3(0.0f,0.0f,1.0f)
    };
  return axis[i];
};
 template<class DataType>
inline Vec3<DataType>
Vec3<DataType>::nonColinearVec() const
{
  return ((*this)^Vec3<DataType>::axis(0)).norm2() > 0.0001f ?
    Vec3<DataType>::axis(0) :
    Vec3<DataType>::axis(1);
}


}
}

#endif // Vec3_H

---