itkMetaArrayReader.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkMetaArrayReader.h,v $
  Language:  C++
  Date:      $Date: 2007-03-22 14:28:51 $
  Version:   $Revision: 1.6 $

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

#include "itkLightProcessObject.h"
#include "itkArray.h"
#include "itkFixedArray.h"
#include "itkVector.h"
#include "itkCovariantVector.h"
#include "itkVariableLengthVector.h"
#include "metaArray.h"

namespace itk
{

class MetaArrayReader : public LightProcessObject
{
public:

  typedef MetaArrayReader          Self;
  typedef LightProcessObject       Superclass;
  typedef SmartPointer<Self>       Pointer;
  typedef SmartPointer<const Self> ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(MetaArrayReader, LightProcessObject);

  itkSetStringMacro(FileName);

  itkGetStringMacro(FileName);

  MetaArray * GetMetaArrayPointer(void);

  void SetBuffer(void * _buffer);

  void Update();

  MET_ValueEnumType GetDataType(void) const
    {
    return m_MetaArray.ElementType();
    }

  int Size(void) const
    {
    return m_MetaArray.Length();
    }

  int GetNumberOfElements(void) const
    {
    return m_MetaArray.Length();
    }

  int GetVectorDimension(void) const
    {
    return m_MetaArray.Length();
    }

  int GetNumberOfComponents(void) const
    {
    return m_MetaArray.Length();
    }

  int GetCovariantVectorDimension(void) const
    {
    return m_MetaArray.Length();
    }

  template <typename TValueType>
  inline void GetElement( TValueType & value, unsigned int i,
                          unsigned int channel=0 ) const
    {
    value = static_cast<TValueType>(m_MetaArray.ElementData( 
              i * m_MetaArray.ElementNumberOfChannels() + channel));
    }

  template <typename TValueType>
  void GetOutput(MET_ValueEnumType _metaElementType,
                   Array<TValueType> * _array,
                   bool _letArrayManageData = true)
    {
    if(m_MetaArray.ElementType() != _metaElementType)
      {
      m_MetaArray.ConvertElementDataTo(_metaElementType);
      }
    _array->SetData((TValueType *)(m_MetaArray.ElementData()), 
                    m_MetaArray.Length(),
                    _letArrayManageData);
    if(_letArrayManageData)
      {
      m_MetaArray.AutoFreeElementData(false);
      }
    }

  template <typename TValueType, unsigned int VLength>
  bool GetOutput(MET_ValueEnumType itkNotUsed(_metaElementType),
                 FixedArray<TValueType, VLength> * _array)
    {
    if(static_cast<int>(VLength) <= m_MetaArray.Length())
      {
      unsigned int i;
      for(i = 0; i<VLength; i++)
        {
        this->GetElement( (*_array)[i], i );
        }
      return true;
      }
    return false;
    }

  template <typename TValueType, unsigned int VLength>
  bool GetOutput(MET_ValueEnumType itkNotUsed(_metaElementType),
                 Vector<TValueType, VLength> * _vector)
    {
    if(static_cast<int>(VLength) <= m_MetaArray.Length())
      {
      unsigned int i;
      for(i = 0; i<VLength; i++)
        {
        this->GetElement( (*_vector)[i], i );
        }
      return true;
      }
    return false;
    }


  template <typename TValueType, unsigned int VLength>
  bool GetOutput(MET_ValueEnumType itkNotUsed(_metaElementType),
                 CovariantVector<TValueType, VLength> * _vector)
    {
    if(static_cast<int>(VLength) <= m_MetaArray.Length())
      {
      unsigned int i;
      for(i = 0; i<VLength; i++)
        {
        this->GetElement( (*_vector)[i], i );
        }
      return true;
      }
    return false;
    }

  template <typename TValueType>
  void GetOutput(MET_ValueEnumType _metaElementType,
                 VariableLengthVector<TValueType> * _vector,
                 bool _letVectorManageData = true)
    {
    if(m_MetaArray.ElementType() != _metaElementType)
      {
      m_MetaArray.ConvertElementDataTo(_metaElementType);
      }
    _vector->SetData((TValueType *)(m_MetaArray.ElementData()), 
                     m_MetaArray.Length(),
                     _letVectorManageData);
    if(_letVectorManageData)
      {
      m_MetaArray.AutoFreeElementData(false);
      }
    }

  template <typename TValueType>
  void GetMultiChannelOutput(MET_ValueEnumType _metaElementType,
                             Array<TValueType> * _array)
    {
    if(m_MetaArray.ElementType() != _metaElementType)
      {
      m_MetaArray.ConvertElementDataTo(_metaElementType);
      }
    int rows = m_MetaArray.Length();
    int cols = m_MetaArray.ElementNumberOfChannels();
    _array->SetSize(rows);
    for(int i=0; i<rows; i++)
      {
      (*_array)[i].SetSize(cols);
      for(int j=0; j<cols; j++)
        {
        (*_array)[i][j] = static_cast<typename TValueType::ValueType>
                                     (m_MetaArray.ElementData(i*cols+j));
        }
      }
    }

protected:

  MetaArrayReader();
  virtual ~MetaArrayReader();

private:

  MetaArray    m_MetaArray;

  std::string  m_FileName;

  void *       m_Buffer;

};

} // namespace itk


#endif // __itkTransformFileReader_h