itkMetaArrayWriter.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkMetaArrayWriter.h,v $
  Language:  C++
  Date:      $Date: 2009-04-25 12:25:44 $
  Version:   $Revision: 1.4 $

  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 __itkMetaArrayWriter_h
#define __itkMetaArrayWriter_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 MetaArrayWriter : public LightProcessObject
{
public:

  typedef MetaArrayWriter           Self;
  typedef LightProcessObject        Superclass;

  typedef SmartPointer<Self>        Pointer;
  typedef SmartPointer<const Self>  ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(MetaArrayWriter, LightProcessObject);

  itkSetStringMacro(FileName);

  itkGetStringMacro(FileName);

  itkSetStringMacro(DataFileName);

  itkGetStringMacro(DataFileName);

  itkSetMacro(Binary, bool);
  itkGetConstMacro(Binary, bool);

  template <typename TValueType>
  void SetInput(MET_ValueEnumType _metaElementType,
                const Array<TValueType> * _array)
    {
    m_Buffer = (const void *)(_array->data_block());
    m_MetaArray.InitializeEssential(_array->Size(),
                                    _metaElementType);
    }

  template <typename TValueType, unsigned int VLength>
  void SetInput(MET_ValueEnumType _metaElementType,
                const FixedArray<TValueType, VLength> * _array)
    {
    m_Buffer = (const void *)(_array->GetDataPointer());
    m_MetaArray.InitializeEssential(VLength,
                                    _metaElementType);
    }

  template <typename TValueType, unsigned int VLength>
  void SetInput(MET_ValueEnumType _metaElementType,
                const Vector<TValueType, VLength> * _vector)
    {
    m_Buffer = (const void *)(_vector->GetDataPointer());
    m_MetaArray.InitializeEssential(VLength,
                                    _metaElementType);
    }

  template <typename TValueType, unsigned int VLength>
  void SetInput(MET_ValueEnumType _metaElementType,
                const CovariantVector<TValueType, VLength> * _vector)
    {
    m_Buffer = (const void *)(_vector->GetDataPointer());
    m_MetaArray.InitializeEssential(VLength,
                                    _metaElementType);
    }

  template <typename TValueType>
  void SetInput(MET_ValueEnumType _metaElementType,
                const VariableLengthVector<TValueType> * _vector)
    {
    m_Buffer = (const void *)(_vector->GetDataPointer());
    m_MetaArray.InitializeEssential(_vector->Size(),
                                    _metaElementType);
    }

  template <typename TValueType>
  void SetMultiChannelInput(MET_ValueEnumType _metaElementType,
                            int _NumberOfChannels,
                            const Array<TValueType> * _array)
    {
    int rows = _array->GetSize();
    int cols = (*_array)[0].GetSize();
    m_MetaArray.InitializeEssential(rows, 
                                    _metaElementType,
                                    cols,
                                    NULL,
                                    true,
                                    true);
    m_Buffer = m_MetaArray.ElementData();
    for(int i=0; i<rows; i++)
      {
      for(int j=0; j<cols; j++)
        {
        m_MetaArray.ElementData(i*cols+j, (double)((*_array)[i][j]));
        }
      }
    }


  itkSetMacro(Precision, unsigned int);
  itkGetConstMacro(Precision, unsigned int);

  void ConvertTo(MET_ValueEnumType _metaElementType);

  void Update();

protected:

  MetaArrayWriter();
  virtual ~MetaArrayWriter();

private:

  bool          m_Binary;

  unsigned int  m_Precision;

  std::string   m_FileName;
  std::string   m_DataFileName;

  MetaArray     m_MetaArray;

  const void *  m_Buffer;

};

} // namespace itk


#endif // __itkMetaArrayWriter_h