itkVariableSizeMatrix.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkVariableSizeMatrix.h,v $
  Language:  C++
  Date:      $Date: 2007-11-05 00:34:00 $
  Version:   $Revision: 1.8 $

  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 __itkVariableSizeMatrix_h
#define __itkVariableSizeMatrix_h


#include "itkPoint.h"
#include "itkVector.h"
#include "itkCovariantVector.h"
#include "vnl/vnl_matrix_fixed.h"
#include "vnl/algo/vnl_matrix_inverse.h"
#include "vnl/vnl_transpose.h"
#include "vnl/vnl_matrix.h"
#include "itkArray.h"


namespace itk
{

template<class T >
class VariableSizeMatrix {
public:
  typedef VariableSizeMatrix  Self;

  typedef T ValueType;
  typedef T ComponentType;

  typedef vnl_matrix<T>  InternalMatrixType;

  Array<T> operator*(const Array<T> & vector) const;

  Self operator*(const Self & matrix) const;

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

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

  Self & operator- ();

  vnl_matrix<T> operator*(const vnl_matrix<T> & matrix) const;

  void operator*=(const Self & matrix);

  void operator*=(const vnl_matrix<T> & matrix);

  vnl_vector<T> operator*(const vnl_vector<T> & matrix) const;

  void operator*=(const T & value)
    { m_Matrix *= value; }

  Self operator*(const T & value)
    {
    Self result( *this );
    result *= value;
    return result;
    }

  void operator/=(const T & value)
    {
    m_Matrix /= value;
    }

  Self operator/(const T & value)
    {
    Self result( *this );
    result /= value;
    return result;
    }

  inline T & operator()( unsigned int row, unsigned int col )
    {
    return m_Matrix(row,col);
    }

  inline const T & operator()( unsigned int row, unsigned int col ) const
    {
    return m_Matrix(row,col);
    }

  inline T * operator[]( unsigned int i )
    {
    return m_Matrix[i];
    }

  inline const T * operator[]( unsigned int i ) const
    {
    return m_Matrix[i];
    }

  inline InternalMatrixType & GetVnlMatrix( void )
    {
    return m_Matrix;
    }

  inline const InternalMatrixType & GetVnlMatrix( void ) const
    {
    return m_Matrix;
    }

  inline void SetIdentity( void ) 
    {
    m_Matrix.set_identity();
    }

  inline void Fill( const T & value ) 
    {
    m_Matrix.fill( value );
    }

  inline const Self & operator=( const vnl_matrix<T> & matrix)
    {
    m_Matrix = matrix;
    return *this;
    }

  inline bool operator==( const Self & matrix) const;
  inline bool operator!=( const Self & matrix) const
    {
    return !this->operator==(matrix);
    }

  inline const Self & operator=( const Self & matrix)
    {
    m_Matrix = matrix.m_Matrix;
    return *this;
    }


  inline vnl_matrix<T> GetInverse( void ) const
    {
    vnl_matrix<T> temp = vnl_matrix_inverse<T>( m_Matrix );
    return temp;
    }

 
  inline vnl_matrix<T> GetTranspose( void ) const
    {
    return m_Matrix.transpose();
    }

  VariableSizeMatrix() : m_Matrix() {};

  VariableSizeMatrix(unsigned int rows, unsigned int cols);

  VariableSizeMatrix(const Self & matrix) : m_Matrix( matrix.m_Matrix ) {};

  inline unsigned int Rows() const { return m_Matrix.rows(); } 

  inline unsigned int Cols() const { return m_Matrix.cols(); } 

  inline bool SetSize( unsigned int r, unsigned int c)
    {  return m_Matrix.set_size( r, c );  }

private:
  InternalMatrixType     m_Matrix;
};

template< class T >  
ITK_EXPORT std::ostream& operator<<(std::ostream& os, 
                                    const VariableSizeMatrix<T> & v) 
{
  os << v.GetVnlMatrix(); return os;
}


  
template<class T>
inline
bool
VariableSizeMatrix<T>
::operator==( const Self & matrix ) const  
{
  if( (matrix.Rows() != this->Rows()) ||
      (matrix.Cols() != this->Cols()))
    { 
    return false;
    }
  bool equal = true;

  for( unsigned int r=0; r<this->Rows(); r++) 
    {
    for( unsigned int c=0; c<this->Cols(); c++ ) 
      {
      if (m_Matrix(r,c) != matrix.m_Matrix(r,c))
        {
        equal = false;
        break;
        }
      }
    }
  return equal;
}

} // end namespace itk
  

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkVariableSizeMatrix.txx"
#endif


#endif