itkMeshIOBase.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  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
 *
 *         https://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 "ITKIOMeshBaseExport.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 "itkCommonEnums.h"
#include "itkMakeUniqueForOverwrite.h"
 
#include <string>
#include <complex>
#include <fstream>
 
namespace itk
{
 
class ITKIOMeshBase_EXPORT MeshIOBase : public LightProcessObject
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(MeshIOBase);

  using Self = MeshIOBase;
  using Superclass = LightProcessObject;
  using ConstPointer = SmartPointer<const Self>;
  using Pointer = SmartPointer<Self>;

  using ArrayOfExtensionsType = std::vector<std::string>;

  using StreamOffsetType = std::streamoff;
 
  using SizeValueType = IdentifierType;

  class UnknownType
  {};

  itkOverrideGetNameOfClassMacro(MeshIOBase);

  itkSetStringMacro(FileName);
  itkGetStringMacro(FileName);
#if !defined(ITK_LEGACY_REMOVE)
  static constexpr IOPixelEnum UNKNOWNPIXELTYPE = IOPixelEnum::UNKNOWNPIXELTYPE;
  static constexpr IOPixelEnum SCALAR = IOPixelEnum::SCALAR;
  static constexpr IOPixelEnum RGB = IOPixelEnum::RGB;
  static constexpr IOPixelEnum RGBA = IOPixelEnum::RGBA;
  static constexpr IOPixelEnum OFFSET = IOPixelEnum::OFFSET;
  static constexpr IOPixelEnum VECTOR = IOPixelEnum::VECTOR;
  static constexpr IOPixelEnum POINT = IOPixelEnum::POINT;
  static constexpr IOPixelEnum COVARIANTVECTOR = IOPixelEnum::COVARIANTVECTOR;
  static constexpr IOPixelEnum SYMMETRICSECONDRANKTENSOR = IOPixelEnum::SYMMETRICSECONDRANKTENSOR;
  static constexpr IOPixelEnum DIFFUSIONTENSOR3D = IOPixelEnum::DIFFUSIONTENSOR3D;
  static constexpr IOPixelEnum COMPLEX = IOPixelEnum::COMPLEX;
  static constexpr IOPixelEnum FIXEDARRAY = IOPixelEnum::FIXEDARRAY;
  static constexpr IOPixelEnum ARRAY = IOPixelEnum::ARRAY;
  static constexpr IOPixelEnum MATRIX = IOPixelEnum::MATRIX;
  static constexpr IOPixelEnum VARIABLELENGTHVECTOR = IOPixelEnum::VARIABLELENGTHVECTOR;
  static constexpr IOPixelEnum VARIABLESIZEMATRIX = IOPixelEnum::VARIABLESIZEMATRIX;
#endif
 
#if !defined(ITK_LEGACY_REMOVE)
  static constexpr IOComponentEnum UNKNOWNCOMPONENTTYPE = IOComponentEnum::UNKNOWNCOMPONENTTYPE;
  static constexpr IOComponentEnum UCHAR = IOComponentEnum::UCHAR;
  static constexpr IOComponentEnum CHAR = IOComponentEnum::CHAR;
  static constexpr IOComponentEnum USHORT = IOComponentEnum::USHORT;
  static constexpr IOComponentEnum SHORT = IOComponentEnum::SHORT;
  static constexpr IOComponentEnum UINT = IOComponentEnum::UINT;
  static constexpr IOComponentEnum INT = IOComponentEnum::INT;
  static constexpr IOComponentEnum ULONG = IOComponentEnum::ULONG;
  static constexpr IOComponentEnum LONG = IOComponentEnum::LONG;
  static constexpr IOComponentEnum ULONGLONG = IOComponentEnum::ULONGLONG;
  static constexpr IOComponentEnum LONGLONG = IOComponentEnum::LONGLONG;
  static constexpr IOComponentEnum FLOAT = IOComponentEnum::FLOAT;
  static constexpr IOComponentEnum DOUBLE = IOComponentEnum::DOUBLE;
  static constexpr IOComponentEnum LDOUBLE = IOComponentEnum::LDOUBLE;
#endif
 
#if !defined(ITK_LEGACY_REMOVE)
  static constexpr IOFileEnum ASCII = IOFileEnum::ASCII;
  static constexpr IOFileEnum BINARY = IOFileEnum::BINARY;
  static constexpr IOFileEnum TYPENOTAPPLICABLE = IOFileEnum::TYPENOTAPPLICABLE;
#endif
 
#if !defined(ITK_LEGACY_REMOVE)
  static constexpr IOByteOrderEnum BigEndian = IOByteOrderEnum::BigEndian;
  static constexpr IOByteOrderEnum LittleEndian = IOByteOrderEnum::LittleEndian;
  static constexpr IOByteOrderEnum OrderNotApplicable = IOByteOrderEnum::OrderNotApplicable;
#endif
 
#if !defined(ITK_LEGACY_REMOVE)
  static constexpr IOFileModeEnum ReadMode = IOFileModeEnum::ReadMode;
  static constexpr IOFileModeEnum WriteMode = IOFileModeEnum::WriteMode;
#endif
 
#if !defined(ITK_LEGACY_REMOVE)
  static constexpr CellGeometryEnum VERTEX_CELL = CellGeometryEnum::VERTEX_CELL;
  static constexpr CellGeometryEnum LINE_CELL = CellGeometryEnum::LINE_CELL;
  static constexpr CellGeometryEnum TRIANGLE_CELL = CellGeometryEnum::TRIANGLE_CELL;
  static constexpr CellGeometryEnum QUADRILATERAL_CELL = CellGeometryEnum::QUADRILATERAL_CELL;
  static constexpr CellGeometryEnum POLYGON_CELL = CellGeometryEnum::POLYGON_CELL;
  static constexpr CellGeometryEnum TETRAHEDRON_CELL = CellGeometryEnum::TETRAHEDRON_CELL;
  static constexpr CellGeometryEnum HEXAHEDRON_CELL = CellGeometryEnum::HEXAHEDRON_CELL;
  static constexpr CellGeometryEnum QUADRATIC_EDGE_CELL = CellGeometryEnum::QUADRATIC_EDGE_CELL;
  static constexpr CellGeometryEnum QUADRATIC_TRIANGLE_CELL = CellGeometryEnum::QUADRATIC_TRIANGLE_CELL;
  static constexpr CellGeometryEnum LAST_ITK_CELL = CellGeometryEnum::LAST_ITK_CELL;
  static constexpr CellGeometryEnum MAX_ITK_CELLS = CellGeometryEnum::MAX_ITK_CELLS;
#endif

  itkSetEnumMacro(PointPixelType, itk::CommonEnums::IOPixel);
  itkGetEnumMacro(PointPixelType, itk::CommonEnums::IOPixel);
  itkSetEnumMacro(CellPixelType, itk::CommonEnums::IOPixel);
  itkGetEnumMacro(CellPixelType, itk::CommonEnums::IOPixel);
  itkSetEnumMacro(PointComponentType, itk::CommonEnums::IOComponent);
  itkGetEnumMacro(PointComponentType, itk::CommonEnums::IOComponent);
  itkSetEnumMacro(CellComponentType, itk::CommonEnums::IOComponent);
  itkGetEnumMacro(CellComponentType, itk::CommonEnums::IOComponent);
  itkSetEnumMacro(PointPixelComponentType, itk::CommonEnums::IOComponent);
  itkGetEnumMacro(PointPixelComponentType, itk::CommonEnums::IOComponent);
  itkSetEnumMacro(CellPixelComponentType, itk::CommonEnums::IOComponent);
  itkGetEnumMacro(CellPixelComponentType, itk::CommonEnums::IOComponent);
  template <typename T>
  struct MapComponentType
  {
    static constexpr IOComponentEnum CType = IOComponentEnum::UNKNOWNCOMPONENTTYPE;
  };
 
  template <typename T>
  void
  SetPixelType(const T & itkNotUsed(dummy), bool usePointPixel = true)
  {
    if (usePointPixel)
    {
      SetNumberOfPointPixelComponents(1);
      SetPointPixelComponentType(MapComponentType<T>::CType);
      SetPointPixelType(IOPixelEnum::SCALAR);
    }
    else
    {
      SetNumberOfCellPixelComponents(1);
      SetCellPixelComponentType(MapComponentType<T>::CType);
      SetCellPixelType(IOPixelEnum::SCALAR);
    }
  }
 
  template <typename T>
  void
  SetPixelType(const RGBPixel<T> & itkNotUsed(dummy), bool usePointPixel = true)
  {
    if (usePointPixel)
    {
      SetNumberOfPointPixelComponents(3);
      SetPointPixelComponentType(MapComponentType<T>::CType);
      SetPointPixelType(IOPixelEnum::RGB);
    }
    else
    {
      SetNumberOfCellPixelComponents(3);
      SetCellPixelComponentType(MapComponentType<T>::CType);
      SetCellPixelType(IOPixelEnum::RGB);
    }
  }
 
  template <typename T>
  void
  SetPixelType(const RGBAPixel<T> & itkNotUsed(dummy), bool usePointPixel = true)
  {
    if (usePointPixel)
    {
      SetNumberOfPointPixelComponents(4);
      SetPointPixelComponentType(MapComponentType<T>::CType);
      SetPointPixelType(IOPixelEnum::RGBA);
    }
    else
    {
      SetNumberOfCellPixelComponents(4);
      SetCellPixelComponentType(MapComponentType<T>::CType);
      SetCellPixelType(IOPixelEnum::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(IOPixelEnum::VECTOR);
    }
    else
    {
      SetNumberOfCellPixelComponents(VLength);
      SetCellPixelComponentType(MapComponentType<T>::CType);
      SetCellPixelType(IOPixelEnum::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(IOPixelEnum::COVARIANTVECTOR);
    }
    else
    {
      SetNumberOfCellPixelComponents(VLength);
      SetCellPixelComponentType(MapComponentType<T>::CType);
      SetCellPixelType(IOPixelEnum::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(IOPixelEnum::FIXEDARRAY);
    }
    else
    {
      SetNumberOfCellPixelComponents(VLength);
      SetCellPixelComponentType(MapComponentType<T>::CType);
      SetCellPixelType(IOPixelEnum::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(IOPixelEnum::SYMMETRICSECONDRANKTENSOR);
    }
    else
    {
      SetNumberOfCellPixelComponents(VLength * (VLength + 1) / 2);
      SetCellPixelComponentType(MapComponentType<T>::CType);
      SetCellPixelType(IOPixelEnum::SYMMETRICSECONDRANKTENSOR);
    }
  }
 
  template <typename T>
  void
  SetPixelType(const DiffusionTensor3D<T> & itkNotUsed(dummy), bool usePointPixel = true)
  {
    if (usePointPixel)
    {
      SetNumberOfPointPixelComponents(6);
      SetPointPixelComponentType(MapComponentType<T>::CType);
      SetPointPixelType(IOPixelEnum::DIFFUSIONTENSOR3D);
    }
    else
    {
      SetNumberOfCellPixelComponents(6);
      SetCellPixelComponentType(MapComponentType<T>::CType);
      SetCellPixelType(IOPixelEnum::DIFFUSIONTENSOR3D);
    }
  }
 
  template <typename T, unsigned int VRows, unsigned int VColumns>
  void
  SetPixelType(const Matrix<T, VRows, VColumns> & itkNotUsed(dummy), bool usePointPixel = true)
  {
    if (usePointPixel)
    {
      SetNumberOfPointPixelComponents(VRows * VColumns);
      SetPointPixelComponentType(MapComponentType<T>::CType);
      SetPointPixelType(IOPixelEnum::MATRIX);
    }
    else
    {
      SetNumberOfCellPixelComponents(VRows * VColumns);
      SetCellPixelComponentType(MapComponentType<T>::CType);
      SetCellPixelType(IOPixelEnum::MATRIX);
    }
  }
 
  template <typename T>
  void
  SetPixelType(const std::complex<T> & itkNotUsed(dummy), bool usePointPixel = true)
  {
    if (usePointPixel)
    {
      SetNumberOfPointPixelComponents(2);
      SetPointPixelComponentType(MapComponentType<T>::CType);
      SetPointPixelType(IOPixelEnum::COMPLEX);
    }
    else
    {
      SetNumberOfCellPixelComponents(2);
      SetCellPixelComponentType(MapComponentType<T>::CType);
      SetCellPixelType(IOPixelEnum::COMPLEX);
    }
  }
 
  template <typename T>
  void
  SetPixelType(const Array<T> & array, bool usePointPixel = true)
  {
    if (usePointPixel)
    {
      SetNumberOfPointPixelComponents(array.Size());
      SetPointPixelComponentType(MapComponentType<T>::CType);
      SetPointPixelType(IOPixelEnum::ARRAY);
    }
    else
    {
      SetNumberOfCellPixelComponents(array.Size());
      SetCellPixelComponentType(MapComponentType<T>::CType);
      SetCellPixelType(IOPixelEnum::ARRAY);
    }
  }
 
  template <typename T>
  void
  SetPixelType(const VariableLengthVector<T> & vector, bool usePointPixel = true)
  {
    if (usePointPixel)
    {
      SetNumberOfPointPixelComponents(vector.Size());
      SetPointPixelComponentType(MapComponentType<T>::CType);
      SetPointPixelType(IOPixelEnum::VARIABLELENGTHVECTOR);
    }
    else
    {
      SetNumberOfCellPixelComponents(vector.Size());
      SetCellPixelComponentType(MapComponentType<T>::CType);
      SetCellPixelType(IOPixelEnum::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(IOPixelEnum::VARIABLESIZEMATRIX);
    }
    else
    {
      SetNumberOfCellPixelComponents(matrix.Rows() * matrix.Cols());
      SetCellPixelComponentType(MapComponentType<T>::CType);
      SetCellPixelType(IOPixelEnum::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);
  itkBooleanMacro(UpdatePoints);
  itkSetMacro(UpdateCells, bool);
  itkGetConstMacro(UpdateCells, bool);
  itkBooleanMacro(UpdateCells);
  itkSetMacro(UpdatePointData, bool);
  itkGetConstMacro(UpdatePointData, bool);
  itkBooleanMacro(UpdatePointData);
  itkSetMacro(UpdateCellData, bool);
  itkGetConstMacro(UpdateCellData, bool);
  itkBooleanMacro(UpdateCellData);
  unsigned int
  GetComponentSize(IOComponentEnum componentType) const;

  static std::string GetComponentTypeAsString(IOComponentEnum);

  static std::string GetPixelTypeAsString(IOPixelEnum);

  itkSetEnumMacro(FileType, IOFileEnum);
  itkGetEnumMacro(FileType, IOFileEnum);
  void
  SetFileTypeToASCII()
  {
    this->SetFileType(IOFileEnum::ASCII);
  }
 
  void
  SetFileTypeToBinary()
  {
    this->SetFileType(IOFileEnum::BINARY);
  }

  itkSetEnumMacro(ByteOrder, IOByteOrderEnum);
  itkGetEnumMacro(ByteOrder, IOByteOrderEnum);
  void
  SetByteOrderToBigEndian()
  {
    this->SetByteOrder(IOByteOrderEnum::BigEndian);
  }
 
  void
  SetByteOrderToLittleEndian()
  {
    this->SetByteOrder(IOByteOrderEnum::LittleEndian);
  }

  itkSetMacro(UseCompression, bool);
  itkGetConstMacro(UseCompression, bool);
  itkBooleanMacro(UseCompression);
  std::string GetFileTypeAsString(IOFileEnum) const;

  std::string GetByteOrderAsString(IOByteOrderEnum) 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();
  ~MeshIOBase() override = default;
 
  void
  PrintSelf(std::ostream & os, Indent indent) const override;

  void
  AddSupportedReadExtension(const char * extension);

  void
  AddSupportedWriteExtension(const char * extension);

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

  template <typename T>
  void
  ReadBufferAsBinary(T * buffer, std::ifstream & inputFile, SizeValueType numberOfComponents)
  {
    inputFile.read(reinterpret_cast<char *>(buffer), numberOfComponents * sizeof(T));
 
    if (m_ByteOrder == IOByteOrderEnum::BigEndian)
    {
      if constexpr (itk::ByteSwapper<T>::SystemIsLittleEndian())
      {
        itk::ByteSwapper<T>::SwapRangeFromSystemToBigEndian(buffer, numberOfComponents);
      }
    }
    else if (m_ByteOrder == IOByteOrderEnum::LittleEndian)
    {
      if constexpr (itk::ByteSwapper<T>::SystemIsBigEndian())
      {
        itk::ByteSwapper<T>::SwapRangeFromSystemToLittleEndian(buffer, numberOfComponents);
      }
    }
  }

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

  template <typename TOutput, typename TInput>
  void
  WriteBufferAsBinary(TInput * buffer, std::ofstream & outputFile, SizeValueType numberOfComponents)
  {
    if (typeid(TInput) == typeid(TOutput))
    {
      if (m_ByteOrder == IOByteOrderEnum::BigEndian && itk::ByteSwapper<TInput>::SystemIsLittleEndian())
      {
        itk::ByteSwapper<TInput>::SwapRangeFromSystemToBigEndian(buffer, numberOfComponents);
      }
      else if (m_ByteOrder == IOByteOrderEnum::LittleEndian && itk::ByteSwapper<TInput>::SystemIsBigEndian())
      {
        itk::ByteSwapper<TInput>::SwapRangeFromSystemToLittleEndian(buffer, numberOfComponents);
      }
 
      outputFile.write(reinterpret_cast<char *>(buffer), numberOfComponents);
    }
    else
    {
      const auto data = make_unique_for_overwrite<TOutput[]>(numberOfComponents);
      for (SizeValueType ii = 0; ii < numberOfComponents; ++ii)
      {
        data[ii] = static_cast<TOutput>(buffer[ii]);
      }
 
      if (m_ByteOrder == IOByteOrderEnum::BigEndian && itk::ByteSwapper<TOutput>::SystemIsLittleEndian())
      {
        itk::ByteSwapper<TOutput>::SwapRangeFromSystemToBigEndian(data.get(), numberOfComponents);
      }
      else if (m_ByteOrder == IOByteOrderEnum::LittleEndian && itk::ByteSwapper<TOutput>::SystemIsBigEndian())
      {
        itk::ByteSwapper<TOutput>::SwapRangeFromSystemToLittleEndian(data.get(), numberOfComponents);
      }
 
      outputFile.write(reinterpret_cast<char *>(data.get()), numberOfComponents);
    }
  }

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

  template <typename TInput, typename TOutput>
  void
  ReadCellsBuffer(TInput * input, TOutput * output, CellGeometryEnum type)
  {
    if (input && output)
    {
      SizeValueType inputIndex{};
      SizeValueType outputIndex{};
 
      for (SizeValueType ii = 0; ii < m_NumberOfCells; ++ii)
      {
        auto cellType = static_cast<CellGeometryEnum>(input[inputIndex++]);
        auto 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 <typename TInput, typename TOutput>
  void
  WriteCellsBuffer(TInput *         input,
                   TOutput *        output,
                   CellGeometryEnum cellType,
                   unsigned int     numberOfPoints,
                   SizeValueType    numberOfCells)
  {
    if (input && output)
    {
      SizeValueType inputIndex{};
      SizeValueType outputIndex{};
      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 <typename TInput, typename TOutput>
  void
  WriteCellsBuffer(TInput * input, TOutput * output, CellGeometryEnum cellType, SizeValueType numberOfCells)
  {
    if (input && output)
    {
      SizeValueType inputIndex{};
      SizeValueType outputIndex{};
      for (SizeValueType ii = 0; ii < numberOfCells; ++ii)
      {
        auto numberOfPoints = static_cast<unsigned int>(input[inputIndex++]);
        if (numberOfPoints > 2 && cellType == CellGeometryEnum::LINE_CELL)
        {
          output[outputIndex++] = static_cast<TOutput>(CellGeometryEnum::POLYLINE_CELL);
        }
        else
        {
          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:
  IOByteOrderEnum m_ByteOrder{ IOByteOrderEnum::OrderNotApplicable };
  IOFileEnum      m_FileType{ IOFileEnum::ASCII };

  std::string m_FileName{};

  bool m_UseCompression{ false };

  IOComponentEnum m_PointComponentType{ IOComponentEnum::UNKNOWNCOMPONENTTYPE };
  IOComponentEnum m_CellComponentType{ IOComponentEnum::UNKNOWNCOMPONENTTYPE };
  IOComponentEnum m_PointPixelComponentType{ IOComponentEnum::UNKNOWNCOMPONENTTYPE };
  IOComponentEnum m_CellPixelComponentType{ IOComponentEnum::UNKNOWNCOMPONENTTYPE };

  IOPixelEnum m_PointPixelType{ IOPixelEnum::SCALAR };
  IOPixelEnum m_CellPixelType{ IOPixelEnum::SCALAR };

  unsigned int m_NumberOfPointPixelComponents{ 0 };
  unsigned int m_NumberOfCellPixelComponents{ 0 };

  unsigned int m_PointDimension{ 3 };

  SizeValueType m_NumberOfPoints{};
  SizeValueType m_NumberOfCells{};
  SizeValueType m_NumberOfPointPixels{};
  SizeValueType m_NumberOfCellPixels{};

  SizeValueType m_CellBufferSize{};

  bool m_UpdatePoints{ false };
  bool m_UpdateCells{ false };
  bool m_UpdatePointData{ false };
  bool m_UpdateCellData{ false };
 
private:
  ArrayOfExtensionsType m_SupportedReadExtensions{};
  ArrayOfExtensionsType m_SupportedWriteExtensions{};
};
#define MESHIOBASE_TYPEMAP(type, ctype)             \
  template <>                                       \
  struct MeshIOBase::MapComponentType<type>         \
  {                                                 \
    static constexpr IOComponentEnum CType = ctype; \
  }
 
MESHIOBASE_TYPEMAP(unsigned char, IOComponentEnum::UCHAR);
MESHIOBASE_TYPEMAP(char, IOComponentEnum::CHAR);
MESHIOBASE_TYPEMAP(unsigned short, IOComponentEnum::USHORT);
MESHIOBASE_TYPEMAP(short, IOComponentEnum::SHORT);
MESHIOBASE_TYPEMAP(unsigned int, IOComponentEnum::UINT);
MESHIOBASE_TYPEMAP(int, IOComponentEnum::INT);
MESHIOBASE_TYPEMAP(unsigned long, IOComponentEnum::ULONG);
MESHIOBASE_TYPEMAP(long, IOComponentEnum::LONG);
MESHIOBASE_TYPEMAP(unsigned long long, IOComponentEnum::ULONGLONG);
MESHIOBASE_TYPEMAP(long long, IOComponentEnum::LONGLONG);
MESHIOBASE_TYPEMAP(float, IOComponentEnum::FLOAT);
MESHIOBASE_TYPEMAP(double, IOComponentEnum::DOUBLE);
MESHIOBASE_TYPEMAP(long double, IOComponentEnum::LDOUBLE);
#undef MESHIOBASE_TYPEMAP
} // end namespace itk
 
#endif