itkVector.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkVector.h,v $
  Language:  C++
  Date:      $Date: 2009-03-03 15:11:37 $
  Version:   $Revision: 1.83 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __itkVector_h
#define __itkVector_h

#include "itkFixedArray.h"

#include "itkNumericTraits.h"   // RealValueType type
#include <vnl/vnl_vector_ref.h> // Get_vnl_vector method return


namespace itk
{

template<class T, unsigned int NVectorDimension=3>
class Vector : public FixedArray<T,NVectorDimension>
{
public:
  typedef Vector                          Self;
  typedef FixedArray<T,NVectorDimension>  Superclass;

  typedef T                                               ValueType;
  typedef typename NumericTraits< ValueType >::RealType   RealValueType;

  itkStaticConstMacro(Dimension, unsigned int, NVectorDimension);

  typedef Self VectorType;

  typedef T ComponentType;

  typedef FixedArray<T, NVectorDimension>                BaseArray;

  static unsigned int GetVectorDimension() 
    { return NVectorDimension; }  

  void SetVnlVector( const vnl_vector<T> & );

  vnl_vector_ref<T> GetVnlVector( void );

  vnl_vector<T> GetVnlVector( void ) const;


  void Set_vnl_vector( const vnl_vector<T> & );

  vnl_vector_ref<T> Get_vnl_vector( void );

  vnl_vector<T> Get_vnl_vector( void ) const;

  Vector(): BaseArray() { }
  Vector(const ValueType& r);

  template< class TVectorValueType >
  Vector(const Vector< TVectorValueType, NVectorDimension>& r): BaseArray(r) {}
  Vector(const ValueType r[Dimension]): BaseArray(r) {}  

  template< class TVectorValueType >
  Vector& operator= (const Vector< TVectorValueType, NVectorDimension> & r)
    {
    BaseArray::operator=(r);
    return *this;
    }

  Vector& operator= (const ValueType r[NVectorDimension]);
    
  template< class Tt > inline const Self& operator*=(const Tt &value)
    {
    for( unsigned int i=0; i<NVectorDimension; i++)
      {
      (*this)[i] = static_cast< ValueType >((*this)[i] * value);
      }
    return *this;
    }

  template< class Tt > inline const Self& operator/=(const Tt &value)
    {
    for( unsigned int i=0; i<NVectorDimension; i++)
      {
      (*this)[i] = static_cast< ValueType >((*this)[i] / value);
      }
    return *this;
    }

  const Self& operator+=(const Self &vec);

  const Self& operator-=(const Self &vec);

  Self operator-() const;

  Self operator+(const Self &vec) const;

  Self operator-(const Self &vec) const;

  ValueType operator*(const Self &vec) const;

  inline Self operator*(const ValueType& value) const
    {
    Self result;
    for( unsigned int i=0; i<NVectorDimension; i++) 
      {
      result[i] = static_cast< ValueType >((*this)[i] * value);
      }
    return result;
    }

  template< class Tt > inline Self operator/(const Tt& value) const
    {
    Self result;
    for( unsigned int i=0; i<NVectorDimension; i++) 
      {
      result[i] = static_cast< ValueType >((*this)[i] / value);
      }
    return result;
    }

  bool operator==(const Self& v) const
    { return Superclass::operator==(v); }
  bool operator!=(const Self& v) const
    { return !operator==(v); }

  RealValueType GetNorm( void ) const;

  RealValueType GetSquaredNorm( void ) const; 

  static unsigned int GetNumberOfComponents(){ return NVectorDimension;}

  void Normalize(void);

  void SetNthComponent(int c, const ComponentType& v)  
    {  this->operator[](c) = v; }
  
  template < typename TCoordRepB >
  void CastFrom( const Vector<TCoordRepB,NVectorDimension> & pa )
    {
    for(unsigned int i=0; i<NVectorDimension; i++ )
      {
      (*this)[i] = static_cast<T>( pa[i] );
      }
    }
};

template< class T, unsigned int NVectorDimension >
inline
Vector<T,NVectorDimension>
operator*(const T &scalar, const  Vector<T,NVectorDimension> & v)
{
  return v * scalar;
}

template< class T, unsigned int NVectorDimension >  
std::ostream& operator<<(std::ostream& os, 
                                    const Vector<T,NVectorDimension> & v); 

template< class T, unsigned int NVectorDimension >  
std::istream& operator>>(std::istream& is, 
                                    Vector<T,NVectorDimension> & v); 

ITKCommon_EXPORT Vector<double,3> CrossProduct( const Vector<double,3> &,
                                          const Vector<double,3> &  );

ITKCommon_EXPORT Vector<float,3> CrossProduct( const Vector<float,3> &,
                                         const Vector<float,3> &  );

ITKCommon_EXPORT Vector<int,3> CrossProduct( const Vector<int,3> &,
                                       const Vector<int,3> &  );

} // end namespace itk


// Define instantiation macro for this template.
#define ITK_TEMPLATE_Vector(_, EXPORT, x, y) namespace itk { \
  _(2(class EXPORT Vector< ITK_TEMPLATE_2 x >)) \
  _(1(EXPORT std::ostream& operator<<(std::ostream&, \
                                      const Vector< ITK_TEMPLATE_2 x >&))) \
  _(1(EXPORT std::istream& operator>>(std::istream&, \
                                      Vector< ITK_TEMPLATE_2 x >&))) \
  namespace Templates { typedef Vector< ITK_TEMPLATE_2 x > Vector##y; } \
  }

#if ITK_TEMPLATE_EXPLICIT
# include "Templates/itkVector+-.h"
#endif

//
// Numeric traits must be included after (optionally) including the explicit
// instantiations control of this class, in case the implicit instantiation
// needs to be disabled. 
//
// NumericTraits must be included before (optionally) including the .txx file,
// in case the .txx requires to use NumericTraits.
//
#include "itkNumericTraitsVectorPixel.h"

#if ITK_TEMPLATE_TXX
# include "itkVector.txx"
#endif


#endif