cmtkMatrix.h

Go to the documentation of this file.

/*
//
//  Copyright 1997-2009 Torsten Rohlfing
//
//  Copyright 2004-2010 SRI International
//
//  This file is part of the Computational Morphometry Toolkit.
//
//  http://www.nitrc.org/projects/cmtk/
//
//  The Computational Morphometry Toolkit is free software: you can
//  redistribute it and/or modify it under the terms of the GNU General Public
//  License as published by the Free Software Foundation, either version 3 of
//  the License, or (at your option) any later version.
//
//  The Computational Morphometry Toolkit is distributed in the hope that it
//  will be useful, but WITHOUT ANY WARRANTY; without even the implied
//  warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License along
//  with the Computational Morphometry Toolkit.  If not, see
//  <http://www.gnu.org/licenses/>.
//
//  $Revision: 2462 $
//
//  $LastChangedDate: 2010-10-19 08:59:01 -0700 (Tue, 19 Oct 2010) $
//
//  $LastChangedBy: torsten_at_home $
//
*/

#ifndef __cmtkMatrix_h_included_
#define __cmtkMatrix_h_included_

#include <cmtkconfig.h>

#include <string.h>
#include <vector>
#include <iostream>

#include <System/cmtkSmartPtr.h>
#include <System/cmtkMemory.h>

namespace
cmtk
{


template<class TElement,size_t NDim>
class Matrix
{
public:
  typedef Matrix<TElement,NDim> Self;

  typedef Matrix<TElement,NDim-1> Superclass;

  Matrix( const size_t (&dims)[NDim] )
    : m_SubMatrixArray( dims[0] )
  {
    size_t nItems = dims[0];
    for ( size_t i = 1; i < NDim; ++i )
      nItems *= dims[i];

    TElement* data = Memory::AllocateArray<TElement>( nItems );
  }

  ~Matrix() {};

  typedef typename Superclass::ElementPointerType* ElementPointerType;

  typename Self::ElementPointerType& operator[]( const size_t idx )
  {
    return this->m_SubMatrixArray[idx];
  }
  
  const typename Self::ElementPointerType& operator[]( const size_t idx ) const
  {
    return this->m_SubMatrixArray[idx];
  }

protected:
  Matrix() {};
  
private:
  std::vector<typename Self::ElementPointerType> m_SubMatrixArray;
}; // class Matrix

template<class TElement>
class Matrix<TElement,1>
{
};

template<class T>
class Matrix2D :
  public std::vector<T*>
{
public:
  typedef std::vector<T*> Superclass;

  typedef Matrix2D<T> Self;

  typedef SmartPointer<Self> SmartPtr;

  typedef std::vector<T*> RowVectorType;  
  
  Matrix2D()
    : Superclass( 1 )
  { 
    this->m_NumberOfColumns = 0;
    this->m_NumberOfRows = 0;
    this->m_NumberOfElements = 0;
    
    (*this)[0] = NULL;
  }
  
  Matrix2D( const size_t dims1, const size_t dims0, const T* data = NULL )
    : Superclass( dims1 )
  { 
    this->m_NumberOfColumns = dims0;
    this->m_NumberOfRows = dims1;
    this->m_NumberOfElements = dims0 * dims1;

    (*this)[0] = Memory::AllocateArray<T>(  this->m_NumberOfElements  );
    for ( size_t i = 1; i < this->m_NumberOfRows; ++i )
      (*this)[i] = (*this)[i-1] + this->m_NumberOfColumns;
    
    if ( data )
      memcpy( (*this)[0], data, this->m_NumberOfElements * sizeof( T ) );
  }
  
  Matrix2D( const Matrix2D<T>& other ) :
    Superclass( other.size() )
  { 
    this->m_NumberOfColumns = other.m_NumberOfColumns;
    this->m_NumberOfRows = other.m_NumberOfRows;
    this->m_NumberOfElements = other.m_NumberOfElements;

    (*this)[0] = Memory::AllocateArray<T>(  this->m_NumberOfElements  );
    for ( size_t i = 1; i < this->m_NumberOfRows; ++i )
      (*this)[i] = (*this)[i-1] + this->m_NumberOfColumns;
    
    memcpy( (*this)[0], other[0], this->m_NumberOfElements * sizeof( T ) );
  }

  ~Matrix2D() 
  {
    if ( (*this)[0] )
      {
      Memory::DeleteArray( (*this)[0] );
      (*this)[0] = NULL;
      }
  }

  size_t GetNumberOfRows() const 
  { 
    return this->m_NumberOfRows;
  }

  size_t GetNumberOfColumns() const 
  { 
    return this->m_NumberOfColumns; 
  }

  void Resize( const size_t numberOfRows, const size_t numberOfColumns )
  {
    if ( (numberOfColumns != this->m_NumberOfColumns) ||
         (numberOfRows != this->m_NumberOfRows) )
      {
      if ( (*this)[0] )
        {
        Memory::DeleteArray( (*this)[0] );
        (*this)[0] = NULL;
        }
      
      this->m_NumberOfColumns = numberOfColumns;
      this->m_NumberOfRows = numberOfRows;
      this->m_NumberOfElements = numberOfColumns * numberOfRows;
      
      this->Superclass::resize( numberOfRows );
      (*this)[0] = Memory::AllocateArray<T>(  this->m_NumberOfElements  );
      for ( size_t i = 1; i < numberOfRows; ++i )
        (*this)[i] = (*this)[i-1] + numberOfColumns;
      }
  }
  
  void SetAllToZero() 
  {
    memset( (*this)[0], 0, this->m_NumberOfElements * sizeof( T ) );
  }
  
  void SetAll( const T value) 
  {
    for ( size_t i = 0; i < this->m_NumberOfElements; ++i ) 
      {
      (*this)[0][i] = value;
      }
  }
  
  Matrix2D<T>& operator= ( const Matrix2D<T>& other ) 
  {
    this->Resize( other.GetNumberOfColumns(), other.GetNumberOfRows() );
    memcpy( (*this)[0], other[0], this->m_NumberOfElements * sizeof( T ) );
    return *this;
  }
  
private:
  size_t m_NumberOfElements;

  size_t m_NumberOfColumns;

  size_t m_NumberOfRows;
};

template<class T>
class Matrix3D :
  public Matrix2D<T*>
{
public:
  typedef Matrix3D<T> Self;

  typedef SmartPointer<Self> SmartPtr;

  typedef Matrix2D<T*> Superclass;

  Matrix3D<T>
  ( const size_t dims2, const size_t dims1, const size_t dims0 )
    : Matrix2D<T*>( dims2, dims1 )
  {
    this->m_NumberOfPlanes = dims0;
    this->m_NumberOfElements = dims0 * dims1 * dims2;
    (*this)[0][0] = Memory::AllocateArray<T>( this->m_NumberOfElements );

    for ( size_t j = 0; j < this->GetNumberOfRows(); ++j )
      for ( size_t i = 0; i < this->GetNumberOfColumns(); ++i )
        if ( i && j )
          {
          (*this)[i][j] = (*this)[0][0] + this->GetNumberOfRows() * ( i + this->GetNumberOfColumns() * j );
          }
  }

  size_t GetNumberOfPlanes() const
  {
    return this->m_NumberOfPlanes;
  }
  
  void Resize( const size_t numberOfRows, const size_t numberOfColumns, const size_t numberOfPlanes )
  {
    if ( ( numberOfColumns != this->GetNumberOfColumns() ) ||
         ( numberOfRows != this->GetNumberOfRows() ) ||
         ( numberOfPlanes != this->GetNumberOfPlanes() ) )
      {
      if ( (*this)[0][0] )
        {
        Memory::DeleteArray( (*this)[0][0] );
        (*this)[0][0] = NULL;
        }
      
      this->m_NumberOfPlanes = numberOfPlanes;
      this->m_NumberOfElements = numberOfPlanes * numberOfRows * numberOfColumns;

      this->Superclass::Resize( numberOfRows, numberOfColumns );
      (*this)[0][0] = Memory::AllocateArray<T>( this->m_NumberOfElements );
      
      for ( size_t j = 0; j < this->GetNumberOfRows(); ++j )
        for ( size_t i = 0; i < this->GetNumberOfColumns(); ++i )
          if ( i && j )
            {
            (*this)[i][j] = (*this)[0][0] + this->GetNumberOfPlanes() * ( i + this->GetNumberOfColumns() * j );
            }
      }
  }
  
  void SetAllToZero() 
  {
    memset( (*this)[0][0], 0, this->m_NumberOfElements * sizeof( T ) );
  }
  
  void SetAll( const T value) 
  {
    for ( size_t i = 0; i < this->m_NumberOfElements; ++i ) 
      {
      (*this)[0][0][i] = value;
      }
  }
  
  Matrix2D<T>& operator= ( const Matrix2D<T>& other ) 
  {
    this->Resize( other.GetNumberOfColumns(), other.GetNumberOfRows(), other.GetNumberOfPlanes() );
    memcpy( (*this)[0], other[0], this->m_NumberOfElements * sizeof( T ) );
    return *this;
  }
  
private:
  size_t m_NumberOfPlanes;

  size_t m_NumberOfElements;
};


} // namespace cmtk

#endif // #ifndef __cmtkMatrix_h_included_