itkMeshIOBase.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef __itkMeshIOBase_h
#define __itkMeshIOBase_h

#include "itkByteSwapper.h"
#include "itkCellInterface.h"
#include "itkCovariantVector.h"
#include "itkDiffusionTensor3D.h"
#include "itkIntTypes.h"
#include "itkLightProcessObject.h"
#include "itkMatrix.h"
#include "itkRGBPixel.h"
#include "itkRGBAPixel.h"
#include "itkSymmetricSecondRankTensor.h"
#include "itkVariableLengthVector.h"
#include "itkVariableSizeMatrix.h"
#include "itkVector.h"
#include "itkNumberToString.h"

#include <string>
#include <complex>
#include <fstream>

namespace itk
{
class ITK_EXPORT MeshIOBase:public LightProcessObject
{
public:
  typedef MeshIOBase                 Self;
  typedef LightProcessObject         Superclass;
  typedef SmartPointer< const Self > ConstPointer;
  typedef SmartPointer< Self >       Pointer;

  typedef  std::vector< std::string > ArrayOfExtensionsType;

  typedef std::streamoff StreamOffsetType;

  typedef IdentifierType SizeValueType;

  class UnknownType {};

  itkTypeMacro(MeshIOBase, LightProcessObject);

  itkSetStringMacro(FileName);
  itkGetStringMacro(FileName);

  typedef  enum {UNKNOWNPIXELTYPE, SCALAR, RGB, RGBA, OFFSET, VECTOR,
                 POINT, COVARIANTVECTOR, SYMMETRICSECONDRANKTENSOR,
                 DIFFUSIONTENSOR3D, COMPLEX, FIXEDARRAY, ARRAY, MATRIX,
                 VARIABLELENGTHVECTOR, VARIABLESIZEMATRIX}  IOPixelType;

  typedef  enum {UNKNOWNCOMPONENTTYPE, UCHAR, CHAR, USHORT, SHORT, UINT, INT,
                 ULONG, LONG, LONGLONG, ULONGLONG, FLOAT, DOUBLE, LDOUBLE} IOComponentType;

  typedef  enum {ASCII, BINARY, TYPENOTAPPLICABLE} FileType;

  typedef  enum {BigEndian, LittleEndian, OrderNotApplicable} ByteOrder;

  typedef  enum {VERTEX_CELL = 0, LINE_CELL, TRIANGLE_CELL,
                 QUADRILATERAL_CELL, POLYGON_CELL, TETRAHEDRON_CELL, HEXAHEDRON_CELL,
                 QUADRATIC_EDGE_CELL, QUADRATIC_TRIANGLE_CELL,
                 LAST_ITK_CELL, MAX_ITK_CELLS = 255}  CellGeometryType;

  itkSetEnumMacro(PointPixelType, IOPixelType);
  itkGetEnumMacro(PointPixelType, IOPixelType);
  itkSetEnumMacro(CellPixelType, IOPixelType);
  itkGetEnumMacro(CellPixelType, IOPixelType);

  itkSetEnumMacro(PointComponentType, IOComponentType);
  itkGetEnumMacro(PointComponentType, IOComponentType);
  itkSetEnumMacro(CellComponentType, IOComponentType);
  itkGetEnumMacro(CellComponentType, IOComponentType);
  itkSetEnumMacro(PointPixelComponentType, IOComponentType);
  itkGetEnumMacro(PointPixelComponentType, IOComponentType);
  itkSetEnumMacro(CellPixelComponentType, IOComponentType);
  itkGetEnumMacro(CellPixelComponentType, IOComponentType);

  template< typename T >
  struct MapComponentType {
    static const IOComponentType CType = UNKNOWNCOMPONENTTYPE;
  };

  template< typename T >
  void SetPixelType(const T & itkNotUsed(dummy), bool UsePointPixel = true)
  {
    if ( UsePointPixel )
      {
      SetNumberOfPointPixelComponents(1);
      SetPointPixelComponentType(MapComponentType< T >::CType);
      SetPointPixelType(SCALAR);
      }
    else
      {
      SetNumberOfCellPixelComponents(1);
      SetCellPixelComponentType(MapComponentType< T >::CType);
      SetCellPixelType(SCALAR);
      }
  }

  template< typename T >
  void SetPixelType(const RGBPixel< T > & itkNotUsed(dummy), bool UsePointPixel = true)
  {
    if ( UsePointPixel )
      {
      SetNumberOfPointPixelComponents(3);
      SetPointPixelComponentType(MapComponentType< T >::CType);
      SetPointPixelType(RGB);
      }
    else
      {
      SetNumberOfCellPixelComponents(3);
      SetCellPixelComponentType(MapComponentType< T >::CType);
      SetCellPixelType(RGB);
      }
  }

  template< typename T >
  void SetPixelType(const RGBAPixel< T > & itkNotUsed(dummy), bool UsePointPixel = true)
  {
    if ( UsePointPixel )
      {
      SetNumberOfPointPixelComponents(4);
      SetPointPixelComponentType(MapComponentType< T >::CType);
      SetPointPixelType(RGBA);
      }
    else
      {
      SetNumberOfCellPixelComponents(4);
      SetCellPixelComponentType(MapComponentType< T >::CType);
      SetCellPixelType(RGBA);
      }
  }

  template< typename T, unsigned int VLength >
  void SetPixelType(const Vector< T, VLength > & itkNotUsed(dummy), bool UsePointPixel = true)
  {
    if ( UsePointPixel )
      {
      SetNumberOfPointPixelComponents(VLength);
      SetPointPixelComponentType(MapComponentType< T >::CType);
      SetPointPixelType(VECTOR);
      }
    else
      {
      SetNumberOfCellPixelComponents(VLength);
      SetCellPixelComponentType(MapComponentType< T >::CType);
      SetCellPixelType(VECTOR);
      }
  }

  template< typename T, unsigned int VLength >
  void SetPixelType(const CovariantVector< T, VLength > & itkNotUsed(dummy), bool UsePointPixel = true)
  {
    if ( UsePointPixel )
      {
      SetNumberOfPointPixelComponents(VLength);
      SetPointPixelComponentType(MapComponentType< T >::CType);
      SetPointPixelType(COVARIANTVECTOR);
      }
    else
      {
      SetNumberOfCellPixelComponents(VLength);
      SetCellPixelComponentType(MapComponentType< T >::CType);
      SetCellPixelType(COVARIANTVECTOR);
      }
  }

  template< typename T, unsigned int VLength >
  void SetPixelType(const FixedArray< T, VLength > & itkNotUsed(dummy), bool UsePointPixel = true)
  {
    if ( UsePointPixel )
      {
      SetNumberOfPointPixelComponents(VLength);
      SetPointPixelComponentType(MapComponentType< T >::CType);
      SetPointPixelType(FIXEDARRAY);
      }
    else
      {
      SetNumberOfCellPixelComponents(VLength);
      SetCellPixelComponentType(MapComponentType< T >::CType);
      SetCellPixelType(FIXEDARRAY);
      }
  }

  template< typename T, unsigned int VLength >
  void SetPixelType(const SymmetricSecondRankTensor< T, VLength > itkNotUsed(dummy), bool UsePointPixel = true)
  {
    if ( UsePointPixel )
      {
      SetNumberOfPointPixelComponents(VLength * ( VLength + 1 ) / 2);
      SetPointPixelComponentType(MapComponentType< T >::CType);
      SetPointPixelType(SYMMETRICSECONDRANKTENSOR);
      }
    else
      {
      SetNumberOfCellPixelComponents(VLength * ( VLength + 1 ) / 2);
      SetCellPixelComponentType(MapComponentType< T >::CType);
      SetCellPixelType(SYMMETRICSECONDRANKTENSOR);
      }
  }

  template< typename T >
  void SetPixelType(const DiffusionTensor3D< T > & itkNotUsed(dummy), bool UsePointPixel = true)
  {
    if ( UsePointPixel )
      {
      SetNumberOfPointPixelComponents(6);
      SetPointPixelComponentType(MapComponentType< T >::CType);
      SetPointPixelType(DIFFUSIONTENSOR3D);
      }
    else
      {
      SetNumberOfCellPixelComponents(6);
      SetCellPixelComponentType(MapComponentType< T >::CType);
      SetCellPixelType(DIFFUSIONTENSOR3D);
      }
  }

  template< typename T, unsigned int NR, unsigned int NC >
  void SetPixelType(const Matrix< T, NR, NC > & itkNotUsed(dummy), bool UsePointPixel = true)
  {
    if ( UsePointPixel )
      {
      SetNumberOfPointPixelComponents(NR * NC);
      SetPointPixelComponentType(MapComponentType< T >::CType);
      SetPointPixelType(MATRIX);
      }
    else
      {
      SetNumberOfCellPixelComponents(NR * NC);
      SetCellPixelComponentType(MapComponentType< T >::CType);
      SetCellPixelType(MATRIX);
      }
  }

  template< typename T >
  void SetPixelType(const std::complex< T > & itkNotUsed(dummy), bool UsePointPixel = true)
  {
    if ( UsePointPixel )
      {
      SetNumberOfPointPixelComponents(2);
      SetPointPixelComponentType(MapComponentType< T >::CType);
      SetPointPixelType(COMPLEX);
      }
    else
      {
      SetNumberOfCellPixelComponents(2);
      SetCellPixelComponentType(MapComponentType< T >::CType);
      SetCellPixelType(COMPLEX);
      }
  }

  template< typename T >
  void SetPixelType(const Array< T > & array, bool UsePointPixel = true)
  {
    if ( UsePointPixel )
      {
      SetNumberOfPointPixelComponents( array.Size() );
      SetPointPixelComponentType(MapComponentType< T >::CType);
      SetPointPixelType(ARRAY);
      }
    else
      {
      SetNumberOfCellPixelComponents( array.Size() );
      SetCellPixelComponentType(MapComponentType< T >::CType);
      SetCellPixelType(ARRAY);
      }
  }

  template< typename T >
  void SetPixelType(const VariableLengthVector< T > & vector, bool UsePointPixel = true)
  {
    if ( UsePointPixel )
      {
      SetNumberOfPointPixelComponents( vector.Size() );
      SetPointPixelComponentType(MapComponentType< T >::CType);
      SetPointPixelType(VARIABLELENGTHVECTOR);
      }
    else
      {
      SetNumberOfCellPixelComponents( vector.Size() );
      SetCellPixelComponentType(MapComponentType< T >::CType);
      SetCellPixelType(VARIABLELENGTHVECTOR);
      }
  }

  template< typename T >
  void SetPixelType(const VariableSizeMatrix< T > & matrix, bool UsePointPixel = true)
  {
    if ( UsePointPixel )
      {
      SetNumberOfPointPixelComponents( matrix.Rows() * matrix.Cols() );
      SetPointPixelComponentType(MapComponentType< T >::CType);
      SetPointPixelType(VARIABLESIZEMATRIX);
      }
    else
      {
      SetNumberOfCellPixelComponents( matrix.Rows() * matrix.Cols() );
      SetCellPixelComponentType(MapComponentType< T >::CType);
      SetCellPixelType(VARIABLESIZEMATRIX);
      }
  }

  itkSetMacro(NumberOfPointPixelComponents, unsigned int);
  itkGetConstMacro(NumberOfPointPixelComponents, unsigned int);
  itkSetMacro(NumberOfCellPixelComponents, unsigned int);
  itkGetConstMacro(NumberOfCellPixelComponents, unsigned int);
  itkSetMacro(PointDimension, unsigned int);
  itkGetConstMacro(PointDimension, unsigned int);
  itkSetMacro(NumberOfPoints, SizeValueType);
  itkGetConstMacro(NumberOfPoints, SizeValueType);
  itkSetMacro(NumberOfCells, SizeValueType);
  itkGetConstMacro(NumberOfCells, SizeValueType);
  itkSetMacro(NumberOfPointPixels, SizeValueType);
  itkGetConstMacro(NumberOfPointPixels, SizeValueType);
  itkSetMacro(NumberOfCellPixels, SizeValueType);
  itkGetConstMacro(NumberOfCellPixels, SizeValueType);
  itkSetMacro(CellBufferSize, SizeValueType);
  itkGetConstMacro(CellBufferSize, SizeValueType);
  itkSetMacro(UpdatePoints, bool);
  itkGetConstMacro(UpdatePoints, bool);
  itkSetMacro(UpdateCells, bool);
  itkGetConstMacro(UpdateCells, bool);
  itkSetMacro(UpdatePointData, bool);
  itkGetConstMacro(UpdatePointData, bool);
  itkSetMacro(UpdateCellData, bool);
  itkGetConstMacro(UpdateCellData, bool);

  unsigned int GetComponentSize(IOComponentType componentType) const;

  std::string GetComponentTypeAsString(IOComponentType) const;

  std::string GetPixelTypeAsString(IOPixelType) const;

  itkSetEnumMacro(FileType, FileType);
  itkGetEnumMacro(FileType, FileType);

  void SetFileTypeToASCII()
  {
    this->SetFileType(ASCII);
  }

  void SetFileTypeToBinary()
  {
    this->SetFileType(BINARY);
  }

  itkSetEnumMacro(ByteOrder, ByteOrder);
  itkGetEnumMacro(ByteOrder, ByteOrder);

  void SetByteOrderToBigEndian()
  {
    this->SetByteOrder(BigEndian);
  }

  void SetByteOrderToLittleEndian()
  {
    this->SetByteOrder(LittleEndian);
  }

  itkSetMacro(UseCompression, bool);
  itkGetConstMacro(UseCompression, bool);
  itkBooleanMacro(UseCompression);

  std::string GetFileTypeAsString(FileType) const;

  std::string GetByteOrderAsString(ByteOrder) const;

  /*-------- This part of the interfaces deals with reading data ----- */
  virtual bool CanReadFile(const char *) = 0;

  virtual void ReadMeshInformation() = 0;

  virtual void ReadPoints(void *buffer) = 0;

  virtual void ReadCells(void *buffer) = 0;

  virtual void ReadPointData(void *buffer) = 0;

  virtual void ReadCellData(void *buffer) = 0;

  /*-------- This part of the interfaces deals with writing data ----- */

  virtual bool CanWriteFile(const char *)  = 0;

  virtual void WriteMeshInformation() = 0;

  virtual void WritePoints(void *buffer) = 0;

  virtual void WriteCells(void *buffer) = 0;

  virtual void WritePointData(void *buffer) = 0;

  virtual void WriteCellData(void *buffer) = 0;

  virtual void Write() = 0;

  const ArrayOfExtensionsType & GetSupportedReadExtensions() const;

  const ArrayOfExtensionsType & GetSupportedWriteExtensions() const;

protected:
  MeshIOBase();
  virtual ~MeshIOBase(){}

  void PrintSelf(std::ostream & os, Indent indent) const;

  void AddSupportedReadExtension(const char *extension);

  void AddSupportedWriteExtension(const char *extension);

  template< class T >
  void ReadBufferAsAscii(T *buffer, std::ifstream & inputFile, SizeValueType numberOfComponents)
  {
    for ( SizeValueType i = 0; i < numberOfComponents; i++ )
      {
      inputFile >> buffer[i];
      }
  }

  template< class T >
  void ReadBufferAsBinary(T *buffer, std::ifstream & inputFile, SizeValueType numberOfComponents)
  {
    inputFile.read( reinterpret_cast< char * >( buffer ), numberOfComponents * sizeof( T ) );

    if ( m_ByteOrder == BigEndian )
      {
      if ( itk::ByteSwapper< T >::SystemIsLittleEndian() )
        {
        itk::ByteSwapper< T >::SwapRangeFromSystemToBigEndian(buffer, numberOfComponents);
        }
      }
    else if ( m_ByteOrder == LittleEndian )
      {
      if ( itk::ByteSwapper< T >::SystemIsBigEndian() )
        {
        itk::ByteSwapper< T >::SwapRangeFromSystemToLittleEndian(buffer, numberOfComponents);
        }
      }
  }

  template< class T >
  void WriteBufferAsAscii(T *buffer, std::ofstream & outputFile, SizeValueType numberOfLines, SizeValueType numberOfComponents)
  {
    NumberToString<T> convert;
    for ( SizeValueType ii = 0; ii < numberOfLines; ii++ )
      {
      for ( SizeValueType jj = 0; jj < numberOfComponents; jj++ )
        {
        outputFile << convert(buffer[ii * numberOfComponents + jj]) << "  ";
        }
      outputFile << '\n';
      }
  }

  template< class TOutput, class TInput >
  void WriteBufferAsBinary(TInput *buffer, std::ofstream & outputFile, SizeValueType numberOfComponents)
  {
    if ( typeid( TInput ) == typeid( TOutput ) )
      {
      if ( m_ByteOrder == BigEndian && itk::ByteSwapper< TInput >::SystemIsLittleEndian() )
        {
        itk::ByteSwapper< TInput >::SwapRangeFromSystemToBigEndian(buffer, numberOfComponents);
        }
      else if ( m_ByteOrder == LittleEndian && itk::ByteSwapper< TInput >::SystemIsBigEndian() )
        {
        itk::ByteSwapper< TInput >::SwapRangeFromSystemToLittleEndian(buffer, numberOfComponents);
        }

      outputFile.write(reinterpret_cast< char * >( buffer ), numberOfComponents);
      }
    else
      {
      TOutput *data = new TOutput[numberOfComponents];
      for ( SizeValueType ii = 0; ii < numberOfComponents; ii++ )
        {
        data[ii] = static_cast< TOutput >( buffer[ii] );
        }

      if ( m_ByteOrder == BigEndian && itk::ByteSwapper< TOutput >::SystemIsLittleEndian() )
        {
        itk::ByteSwapper< TOutput >::SwapRangeFromSystemToBigEndian(data, numberOfComponents);
        }
      else if ( m_ByteOrder == LittleEndian && itk::ByteSwapper< TOutput >::SystemIsBigEndian() )
        {
        itk::ByteSwapper< TOutput >::SwapRangeFromSystemToLittleEndian(data, numberOfComponents);
        }

      outputFile.write(reinterpret_cast< char * >( data ), numberOfComponents);
      }
  }

  template< class TInput, class TOutput >
  void ReadCellsBuffer(TInput *input, TOutput *output)
  {
    if ( input && output )
      {
      SizeValueType inputIndex = NumericTraits< SizeValueType >::Zero;
      SizeValueType outputIndex = NumericTraits< SizeValueType >::Zero;
      for ( SizeValueType ii = 0; ii < m_NumberOfCells; ii++ )
        {
        inputIndex++; // ignore the cell type
        unsigned int numberOfPoints = static_cast< unsigned int >( input[inputIndex++] );
        for ( unsigned int jj = 0; jj < numberOfPoints; jj++ )
          {
          output[outputIndex++] = static_cast< TOutput >( input[inputIndex++] );
          }
        }
      }
  }

  template< class TInput, class TOutput >
  void ReadCellsBuffer(TInput *input, TOutput *output, MeshIOBase::CellGeometryType type)
  {
    if ( input && output )
      {
      SizeValueType inputIndex = itk::NumericTraits< SizeValueType >::Zero;
      SizeValueType outputIndex = itk::NumericTraits< SizeValueType >::Zero;

      for ( SizeValueType ii = 0; ii < m_NumberOfCells; ii++ )
        {
        MeshIOBase::CellGeometryType cellType = static_cast< MeshIOBase::CellGeometryType >( input[inputIndex++] );
        unsigned int                 nn = static_cast< unsigned int >( input[inputIndex++] );
        if ( cellType == type )
          {
          output[outputIndex++] = nn;
          for ( unsigned int jj = 0; jj < nn; jj++ )
            {
            output[outputIndex++] = static_cast< TOutput >( input[inputIndex++] );
            }
          }
        else
          {
          inputIndex += nn;
          }
        }
      }
  }

  template< class TInput, class TOutput >
  void WriteCellsBuffer(TInput *input, TOutput *output, CellGeometryType cellType, unsigned int numberOfPoints, SizeValueType numberOfCells)
  {
    if ( input && output )
      {
      SizeValueType inputIndex = NumericTraits< SizeValueType >::Zero;
      SizeValueType outputIndex = NumericTraits< SizeValueType >::Zero;
      for ( SizeValueType ii = 0; ii < numberOfCells; ii++ )
        {
        output[outputIndex++] = static_cast< TOutput >( cellType );
        output[outputIndex++] = static_cast< TOutput >( numberOfPoints );
        for ( unsigned int jj = 0; jj < numberOfPoints; jj++ )
          {
          output[outputIndex++] = static_cast< TOutput >( input[inputIndex++] );
          }
        }
      }
  }

  template< class TInput, class TOutput >
  void WriteCellsBuffer(TInput *input, TOutput *output, CellGeometryType cellType, SizeValueType numberOfCells)
  {
    if ( input && output )
      {
      SizeValueType inputIndex = NumericTraits< SizeValueType >::Zero;
      SizeValueType outputIndex = NumericTraits< SizeValueType >::Zero;
      for ( SizeValueType ii = 0; ii < numberOfCells; ii++ )
        {
        unsigned int numberOfPoints = static_cast< unsigned int >( input[inputIndex++] );
        output[outputIndex++] = static_cast< TOutput >( cellType );
        output[outputIndex++] = static_cast< TOutput >( numberOfPoints );
        for ( unsigned int jj = 0; jj < numberOfPoints; jj++ )
          {
          output[outputIndex++] = static_cast< TOutput >( input[inputIndex++] );
          }
        }
      }
  }

protected:
  ByteOrder m_ByteOrder;
  FileType  m_FileType;

  std::string m_FileName;

  bool m_UseCompression;

  IOComponentType m_PointComponentType;
  IOComponentType m_CellComponentType;
  IOComponentType m_PointPixelComponentType;
  IOComponentType m_CellPixelComponentType;

  IOPixelType m_PointPixelType;
  IOPixelType m_CellPixelType;

  unsigned int m_NumberOfPointPixelComponents;
  unsigned int m_NumberOfCellPixelComponents;

  unsigned int m_PointDimension;

  SizeValueType m_NumberOfPoints;
  SizeValueType m_NumberOfCells;
  SizeValueType m_NumberOfPointPixels;
  SizeValueType m_NumberOfCellPixels;

  SizeValueType m_CellBufferSize;

  bool m_UpdatePoints;
  bool m_UpdateCells;
  bool m_UpdatePointData;
  bool m_UpdateCellData;

private:
  MeshIOBase(const Self &);     // purposely not implemented
  void operator=(const Self &); // purposely not implemented

  ArrayOfExtensionsType m_SupportedReadExtensions;
  ArrayOfExtensionsType m_SupportedWriteExtensions;
};
#define MESHIOBASE_TYPEMAP(type, ctype)            \
  template< >                                      \
  struct MeshIOBase:: MapComponentType< type >     \
  {                                                \
    static const IOComponentType CType = ctype;    \
  }

MESHIOBASE_TYPEMAP(unsigned char, UCHAR);
MESHIOBASE_TYPEMAP(char, CHAR);
MESHIOBASE_TYPEMAP(unsigned short, USHORT);
MESHIOBASE_TYPEMAP(short, SHORT);
MESHIOBASE_TYPEMAP(unsigned int, UINT);
MESHIOBASE_TYPEMAP(int, INT);
MESHIOBASE_TYPEMAP(unsigned long, ULONG);
MESHIOBASE_TYPEMAP(long, LONG);
MESHIOBASE_TYPEMAP(unsigned long long, ULONGLONG);
MESHIOBASE_TYPEMAP(long long, LONGLONG);
MESHIOBASE_TYPEMAP(float, FLOAT);
MESHIOBASE_TYPEMAP(double, DOUBLE);
MESHIOBASE_TYPEMAP(long double, LDOUBLE);
#undef MESHIOBASE_TYPEMAP
} // end namespace itk

#endif