/vol/vipdata/irtk/geometry++/include/irtkVector3D.h

/*=========================================================================
 
  Library   : Image Registration Toolkit (IRTK)
  Module    : $Id: irtkVector3D.h 8 2009-03-02 16:12:58Z dr $
  Copyright : Imperial College, Department of Computing
              Visual Information Processing (VIP), 2008 onwards
  Date      : $Date: 2009-03-02 16:12:58 +0000 (Mon, 02 Mar 2009) $
  Version   : $Revision: 8 $
  Changes   : $Author: dr $
 
=========================================================================*/

#ifndef _IRTKVECTOR3D_H

#define _IRTKVECTOR3D_H

#include <cmath>
#include <limits>

#include <irtkObject.h>

template <typename T> class irtkVector3D : public irtkObject
{
public:
  T _x;

  T _y;

  T _z;

  irtkVector3D(T x = 0, T y = 0, T z = 0);

  void Normalize();

  double Length() const;

  irtkVector3D operator*(double s);

  irtkVector3D operator+(const irtkVector3D& v);

  irtkVector3D operator-(const irtkVector3D& v);

  irtkVector3D& operator*=(double s);

  irtkVector3D& operator*=(const irtkVector3D& v);

  irtkVector3D& operator+=(const irtkVector3D& v);

  irtkVector3D& operator-=(const irtkVector3D& v);

  bool operator==(const irtkVector3D& v);

  bool operator!=(const irtkVector3D& v);

  bool operator<(const irtkVector3D& v);

  bool operator>(const irtkVector3D& v);

  bool operator<=(const irtkVector3D& v);

  bool operator>=(const irtkVector3D& v);

  irtkVector3D& operator/=(const irtkVector3D& v);

  irtkVector3D operator/(const irtkVector3D& v);

  irtkVector3D& operator/=(double s);

  irtkVector3D operator/(double s);

  static irtkVector3D CrossProduct(const irtkVector3D& v1, const irtkVector3D& v2);

  static double DotProduct(const irtkVector3D& v1, const irtkVector3D& v2);

};

template <typename T> inline irtkVector3D<T>::irtkVector3D(T x, T y, T z)
{
  _x = x;
  _y = y;
  _z = z;
}

template <typename T> inline void irtkVector3D<T>::Normalize()
{
  double length = sqrt(static_cast<double>(_x*_x + _y*_y + _z*_z));

  if (length != 0) {
    _x = static_cast<T>(_x/length);
    _y = static_cast<T>(_y/length);
    _z = static_cast<T>(_z/length);
  }
}

template <typename T> inline double irtkVector3D<T>::Length() const
{
  return sqrt(static_cast<double>(_x*_x + _y*_y + _z*_z));
}

template<typename T> inline irtkVector3D<T> irtkVector3D<T>::CrossProduct(const irtkVector3D<T>& v1, const irtkVector3D<T>& v2)
{
  irtkVector3D<T> cp;

  cp._x = v1._y*v2._z - v1._z*v2._y;
  cp._y = v1._z*v2._x - v1._x*v2._z;
  cp._z = v1._x*v2._y - v1._y*v2._x;

  return cp;
}

template <typename T> inline double irtkVector3D<T>::DotProduct(const irtkVector3D<T>& v1, const irtkVector3D<T>& v2)
{
  return v1._x*v2._x + v1._y*v2._y + v1._z*v2._z;
}

template <typename T> inline irtkVector3D<T> irtkVector3D<T>::operator*(double s)
{
  irtkVector3D<T> r;

  r._x = static_cast<T>(_x*s);
  r._y = static_cast<T>(_y*s);
  r._z = static_cast<T>(_z*s);

  return r;
}

template <typename T> inline irtkVector3D<T> irtkVector3D<T>::operator+(const irtkVector3D<T>& v)
{
  irtkVector3D<T> r;

  r._x = _x + v._x;
  r._y = _y + v._y;
  r._z = _z + v._z;

  return r;
}

template <typename T> inline irtkVector3D<T> irtkVector3D<T>::operator-(const irtkVector3D<T>& v)
{
  irtkVector3D<T> r;

  r._x = _x - v._x;
  r._y = _y - v._y;
  r._z = _z - v._z;

  return r;
}


template <typename T> inline irtkVector3D<T>& irtkVector3D<T>::operator*=(double s)
{
  _x = static_cast<T>(_x*s);
  _y = static_cast<T>(_y*s);
  _z = static_cast<T>(_z*s);

  return *this;
}

template <typename T> inline irtkVector3D<T>& irtkVector3D<T>::operator*=(const irtkVector3D<T>& v)
{
  _x *= v._x;
  _y *= v._y;
  _z *= v._z;

  return *this;
}

template <typename T> inline irtkVector3D<T>& irtkVector3D<T>::operator+=(const irtkVector3D<T>& v)
{
  _x += v._x;
  _y += v._y;
  _z += v._z;

  return *this;
}

template <typename T> inline irtkVector3D<T>& irtkVector3D<T>::operator-=(const irtkVector3D<T>& v)
{
  _x -= v._x;
  _y -= v._y;
  _z -= v._z;

  return *this;
}

template <typename T> inline bool irtkVector3D<T>::operator==(const irtkVector3D<T>& v)
{
  return ((_z == v._z) && (_y == v._y) && (_x == v._x));
}

template <typename T> inline bool irtkVector3D<T>::operator!=(const irtkVector3D<T>& v)
{
  return ((_z != v._z) || (_y != v._y) || (_x != v._x));
}

template <typename T> inline bool irtkVector3D<T>::operator<(const irtkVector3D<T>& v)
{
  return ((_z < v._z) ||
          ((_z == v._z) && (_y < v._y)) ||
          ((_z == v._z) && (_y == v._y) && (_x < v._x)));
}

template <typename T> inline bool irtkVector3D<T>::operator>(const irtkVector3D<T>& v)
{
  return ((_z > v._z) ||
          ((_z == v._z) && (_y > v._y)) ||
          ((_z == v._z) && (_y == v._y) && (_x > v._x)));
}

template <typename T> inline bool irtkVector3D<T>::operator<=(const irtkVector3D<T>& v)
{
  return ((*this < v) || (*this == v));
}

template <typename T> inline bool irtkVector3D<T>::operator>=(const irtkVector3D<T>& v)
{
  return ((*this > v) || (*this == v));
}

template <typename T> inline irtkVector3D<T>& irtkVector3D<T>::operator/=(double s)
{
  _x = static_cast<T>(_x/s);
  _y = static_cast<T>(_y/s);
  _z = static_cast<T>(_z/s);

  return *this;
}

template <typename T> inline irtkVector3D<T> irtkVector3D<T>::operator/(double s)
{
  return irtkVector3D<T>(static_cast<T>(_x/s), static_cast<T>(_y/s), static_cast<T>(_z/s));
}

#endif // __IRTKVECTOR3D_H

Generated on Mon Mar 23 16:55:52 2009 for IRTK by Doxygen 1.5.4