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

/*=========================================================================

  Library   : Image Registration Toolkit (IRTK)
  Module    : $Id: irtkVector.h 2 2008-12-23 12:40:14Z dr $
  Copyright : Imperial College, Department of Computing
              Visual Information Processing (VIP), 2008 onwards
  Date      : $Date: 2008-12-23 12:40:14 +0000 (Tue, 23 Dec 2008) $
  Version   : $Revision: 2 $
  Changes   : $Author: dr $

=========================================================================*/

#ifndef _IRTKVECTOR_H

#define _IRTKVECTOR_H

#ifdef USE_VXL
// VXL header file was loaded in irtkMatrix.h
#include <vnl/vnl_diag_matrix.h>
#endif

class irtkVector : public irtkObject
{

protected:

  int _rows;

  double *_vector;

public:

  irtkVector();

  irtkVector(int);

  irtkVector(const irtkVector &);

  ~irtkVector();

  void Initialize(int);

  //
  // Vector access functions
  //

  int Rows() const;

  void   Put(int, double);

  double Get(int) const;

  //
  // Operators for vector access
  //

  double &operator()(int);

  double  operator()(int) const;

  //
  // Vector operators for doubles
  //

  irtkVector& operator-=(double);

  irtkVector& operator+=(double);

  irtkVector& operator*=(double);

  irtkVector& operator/=(double);

  irtkVector  operator- (double);

  irtkVector  operator+ (double);

  irtkVector  operator* (double);

  irtkVector  operator/ (double);

  //
  // Vector operators for vectors
  //

  irtkVector& operator =(const irtkVector&);

  irtkVector& operator-=(const irtkVector&);

  irtkVector& operator+=(const irtkVector&);

  irtkVector& operator*=(const irtkVector&);

  irtkVector& operator/=(const irtkVector&);

  irtkVector  operator- (const irtkVector&);

  irtkVector  operator+ (const irtkVector&);

  irtkVector  operator* (const irtkVector&);

  irtkVector  operator/ (const irtkVector&);

  Bool operator==(const irtkVector &);

#ifndef USE_STL
  Bool operator!=(const irtkVector &);
#endif

  Bool operator<(const irtkVector &);

  double ScalarProduct(const irtkVector&);

  irtkVector CrossProduct(const irtkVector&);

  double Norm(void) const;

  void   Normalize(void);

  //
  // Vector in- and output
  //

  friend ostream& operator<< (ostream&, const irtkVector&);

  friend istream& operator>> (istream&, irtkVector&);

  void Print();

  void Read (char *);

  void Write(char *);


#ifdef USE_VXL
  template <class T> void Vector2Vnl(vnl_diag_matrix<T>*) const;

  template <class T> void Vnl2Vector(vnl_diag_matrix<T>*);

#else
  void Vector2NR(float *) const;
  void Vector2NR(double *) const;

  void NR2Vector(float *);
  void NR2Vector(double *);
#endif

};

//
// Access operators
//

inline int irtkVector::Rows() const
{
  return _rows;
}

inline void irtkVector::Put(int rows, double vector)
{
  _vector[rows] = vector;
}

inline double irtkVector::Get(int rows) const
{
  return _vector[rows];
}

inline double& irtkVector::operator()(int rows)
{
  return _vector[rows];
}

inline double irtkVector::operator()(int rows) const
{
  return _vector[rows];
}

//
// Vector operators for doubles
//

inline irtkVector& irtkVector::operator-=(double x)
{
  int i;

  for (i = 0; i < _rows; i++) {
    _vector[i] -= x;
  }

  return *this;
}

inline irtkVector& irtkVector::operator+=(double x)
{
  int i;

  for (i = 0; i < _rows; i++) {
    _vector[i] += x;
  }

  return *this;
}

inline irtkVector& irtkVector::operator*=(double x)
{
  int i;

  for (i = 0; i < _rows; i++) {
    _vector[i] *= x;
  }

  return *this;
}

inline irtkVector& irtkVector::operator/=(double x)
{
  int i;

  for (i = 0; i < _rows; i++) {
    _vector[i] /= x;
  }

  return *this;
}

inline irtkVector irtkVector::operator- (double x)
{
  int i;

  irtkVector m(_rows);
  for (i = 0; i < _rows; i++) {
    m._vector[i] = _vector[i] - x;
  }
  return m;
}

inline irtkVector irtkVector::operator+ (double x)
{
  int i;

  irtkVector m(_rows);
  for (i = 0; i < _rows; i++) {
    m._vector[i] = _vector[i] + x;
  }
  return m;
}

inline irtkVector irtkVector::operator* (double x)
{
  int i;

  irtkVector m(_rows);
  for (i = 0; i < _rows; i++) {
    m._vector[i] = _vector[i] * x;
  }
  return m;
}

inline irtkVector irtkVector::operator/ (double x)
{
  int i;

  irtkVector m(_rows);
  for (i = 0; i < _rows; i++) {
    m._vector[i] = _vector[i] / x;
  }
  return m;
}

//
// Vector operators for vectors
//

inline irtkVector& irtkVector::operator =(const irtkVector& v)
{
  int i;

  // Copy size
  this->Initialize(v._rows);

  // Copy vector
  for (i = 0; i < _rows; i++) {
    _vector[i] = v._vector[i];
  }
  return *this;
}

inline irtkVector& irtkVector::operator-=(const irtkVector& v)
{
  int i;

  if (_rows != v._rows) {
    cerr << "irtkVector::operator-=: Size mismatch" << endl;
    exit(1);
  }
  for (i = 0; i < _rows; i++) {
    _vector[i] -= v._vector[i];
  }

  return *this;
}

inline irtkVector& irtkVector::operator+=(const irtkVector& v)
{
  int i;

  if (_rows != v._rows) {
    cerr << "irtkVector::operator+=: Size mismatch" << endl;
    exit(1);
  }
  for (i = 0; i < _rows; i++) {
    _vector[i] += v._vector[i];
  }

  return *this;
}

inline irtkVector& irtkVector::operator*=(const irtkVector& v)
{
  int i;

  if (_rows != v._rows) {
    cerr << "irtkVector::operator*=: Size mismatch" << endl;
    exit(1);
  }
  for (i = 0; i < _rows; i++) {
    _vector[i] *= v._vector[i];
  }

  return *this;
}

inline irtkVector& irtkVector::operator/=(const irtkVector& v)
{
  int i;

  if (_rows != v._rows) {
    cerr << "irtkVector::operator/=: Size mismatch" << endl;
    exit(1);
  }
  for (i = 0; i < _rows; i++) {
    _vector[i] /= v._vector[i];
  }

  return *this;
}

inline irtkVector irtkVector::operator- (const irtkVector& v)
{
  int i;

  if (_rows != v._rows) {
    cerr << "irtkVector::operator-: Size mismatch" << endl;
    exit(1);
  }
  irtkVector m(_rows);
  for (i = 0; i < _rows; i++) {
    m._vector[i] = _vector[i] - v._vector[i];
  }
  return m;
}

inline irtkVector irtkVector::operator+ (const irtkVector& v)
{
  int i;

  if (_rows != v._rows) {
    cerr << "irtkVector::operator+: Size mismatch" << endl;
    exit(1);
  }
  irtkVector m(_rows);
  for (i = 0; i < _rows; i++) {
    m._vector[i] = _vector[i] + v._vector[i];
  }
  return m;
}

inline irtkVector irtkVector::operator* (const irtkVector& v)
{
  int i;

  if (_rows != v._rows) {
    cerr << "irtkVector::operator*: Size mismatch" << endl;
    exit(1);
  }
  irtkVector m(_rows);
  for (i = 0; i < _rows; i++) {
    m._vector[i] = _vector[i] * v._vector[i];
  }
  return m;
}

inline irtkVector irtkVector::operator/ (const irtkVector& v)
{
  int i;

  if (_rows != v._rows) {
    cerr << "irtkVector::operator/: Size mismatch" << endl;
    exit(1);
  }
  irtkVector m(_rows);
  for (i = 0; i < _rows; i++) {
    m._vector[i] = _vector[i] / v._vector[i];
  }
  return m;
}

//
// Comparison
//

inline Bool  irtkVector::operator==(const irtkVector &v)
{
  if (_rows != v._rows) {
    return False;
  }
  for (int i = 0; i < _rows; i++) {
    if (_vector[i] != v._vector[i]) return False;
  }
  return True;

}

#ifndef USE_STL
inline Bool  irtkVector::operator!=(const irtkVector &v)
{
  if (_rows != v._rows) {
    return True;
  }
  for (int i = 0; i < _rows; i++) {
    if (_vector[i] != v._vector[i]) return True;
  }
  return False;
}
#endif

inline Bool  irtkVector::operator<(const irtkVector &v)
{
  if (_rows > v._rows) {
    return False;
  }
  for (int i = 0; i < _rows; i++) {
    if (_vector[i] >= v._vector[i]) return False;
  }
  return True;

}

//
// Vector products
//

inline double irtkVector::ScalarProduct(const irtkVector &v)
{
  int i;
  double scalar_product=0;

  if (_rows != v._rows) {
    cerr << "irtkVector::ScalarProduct: Size mismatch" << endl;
    exit(1);
  }

  for (i = 0; i < _rows; i++) {
    scalar_product += _vector[i]*v._vector[i];
  }
  return scalar_product;
}

inline irtkVector irtkVector::CrossProduct(const irtkVector &v)
{
  int i;

  if (_rows != v._rows) {
    cerr << "irtkVector::CrossProduct: Size mismatch" << endl;
    exit(1);
  }

  irtkVector m(_rows);
  for (i = 0; i < _rows; i++) {
    m._vector[i] = (_vector[(i+1)%_rows]*v._vector[(i+2)%_rows]-
                    _vector[(i+2)%_rows]*v._vector[(i+1)%_rows]);
  }
  return m;
}


//
// Functions
//

inline double irtkVector::Norm(void) const
{
  double norm = 0;

  for (int i = 0; i < _rows; i++) {
    norm += _vector[i]*_vector[i];
  }
  return sqrt(norm);
}

inline void irtkVector::Normalize(void)
{
  double norm = Norm();

  if (norm != 0) {
    *this /= norm;
  }
}

#ifdef USE_VXL

template <class T>
inline void irtkVector::Vector2Vnl(vnl_diag_matrix<T>* m) const
{
  unsigned i;

  for (i = 0; i < (unsigned) _rows; i++) {
    (*m)(i) = (T) _vector[i];
  }
}

template <class T>
inline void irtkVector::Vnl2Vector(vnl_diag_matrix<T>* m)
{
  unsigned i;

  for (i = 0; i < (unsigned) _rows; i++) {
    _vector[i] = (float) (*m)(i);
  }
}

#endif

#endif

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