itkSTLMeshIO.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 __itkSTLMeshIO_h
#define __itkSTLMeshIO_h

#include "IOSTLExport.h"

#include "itkMeshIOBase.h"

#include <fstream>
#include <set>

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

  itkNewMacro(Self);

  itkTypeMacro(STLMeshIO, MeshIOBase);

  virtual bool CanReadFile(const char *FileNameToRead);

  virtual void Read();

  virtual void ReadMeshInformation();

  virtual void ReadPoints(void *buffer);

  virtual void ReadCells(void *buffer);

  virtual bool GetUpdatePoints() const;

  virtual bool GetUpdateCells() const;

  virtual void ReadPointData( void * itkNotUsed(buffer) ) {};
  virtual void ReadCellData( void * itkNotUsed(buffer) ) {};

  /*-------- This part of the interfaces deals with writing data. ----- */
  virtual bool CanWriteFile(const char *FileNameToWrite);

  virtual void WriteMeshInformation();

  virtual void Write();

  virtual void WritePoints( void * buffer );

  virtual void WriteCells(void *buffer);

  virtual void WritePointData( void * itkNotUsed(buffer) ) {};
  virtual void WriteCellData( void * itkNotUsed(buffer) ) {};

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

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

  template< typename TPointsBuffer >
  void WritePointsTyped( const TPointsBuffer * const buffer )
  {

    const unsigned int pointDimension = this->GetPointDimension();

    if ( pointDimension != 3 )
      {
      itkExceptionMacro("STL only supports 3D points");
      }

    const TPointsBuffer * pointCoordinates = buffer;

    this->m_Points.clear();

    const IdentifierType numberOfPoints = this->GetNumberOfPoints();

    this->m_Points.resize(numberOfPoints);

    for( IdentifierType pi = 0; pi < numberOfPoints; ++pi )
      {
      for( unsigned int i = 0; i < pointDimension; ++i )
        {
        m_Points[pi][i] = static_cast< PointValueType >( *pointCoordinates++ );
        }
      }

  }


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

  std::ofstream   m_OutputStream;  // output file
  std::ifstream   m_InputStream;   // input file

  std::string     m_InputLine;     // helper during reading

  typedef float  PointValueType; // type to represent point coordinates

  typedef Point< PointValueType, 3 >              PointType;
  typedef Vector< PointValueType, 3 >             VectorType;
  typedef CovariantVector< PointValueType, 3 >    NormalType;

  typedef std::vector< PointType >                PointContainerType;

  void WriteInt32AsBinary(int32_t value);
  void WriteInt16AsBinary(int16_t value);
  void WriteNormalAsBinary(const NormalType & normal);
  void WritePointAsBinary(const PointType & point);

  void ReadMeshInternalFromAscii();
  void ReadMeshInternalFromBinary();

  void ReadInt32AsBinary(int32_t & value);
  void ReadInt16AsBinary(int16_t & value);
  void ReadNormalAsBinary(NormalType & normal);
  void ReadPointAsBinary(PointType & point);

  void ReadStringFromAscii(const std::string & keyword);
  void ReadPointAsAscii(PointType & point);
  bool CheckStringFromAscii(const std::string & expected);

  virtual void WriteCellsAsAscii(void *buffer);
  virtual void WriteCellsAsBinary(void *buffer);

  void InsertPointIntoSet( const PointType & point );

  PointContainerType    m_Points;

  unsigned int          m_InputLineNumber;

  struct PointCompare
  {
    bool operator()(const PointType & p1, const PointType & p2) const
    {
        if( p1[0] != p2[0] )
          {
          return p1[0] < p2[0];
          }
        else
          {
          if( p1[1] != p2[1] )
            {
            return p1[1] < p2[1];
            }
          }

        return p1[2] < p2[2];
    }
  };

  typedef std::map< PointType, IdentifierType, PointCompare >  PointsMapType;

  PointsMapType         m_PointsMap;

  // Helper variable to put Ids in points as they are read
  IdentifierType        m_LatestPointId;

  // Triplet to hold the Ids of points in a triagle as they are being read
  class TripletType
  {
    public:
      IdentifierType  p0;
      IdentifierType  p1;
      IdentifierType  p2;
  };

  TripletType             m_TrianglePointIds;
  unsigned int            m_PointInTriangleCounter;

  typedef std::vector< TripletType >    CellsVectorType;
  CellsVectorType                       m_CellsVector;

};
} // end namespace itk

#endif // __itkSTLMeshIO_h