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:
  ITK_DISALLOW_COPY_AND_ASSIGN(STLMeshIO);

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

  itkNewMacro(Self);

  itkTypeMacro(STLMeshIO, MeshIOBase);

  bool CanReadFile(const char *FileNameToRead) override;

  virtual void Read();

  void ReadMeshInformation() override;

  void ReadPoints(void *buffer) override;

  void ReadCells(void *buffer) override;

  bool GetUpdatePoints() const override;

  bool GetUpdateCells() const override;

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

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

  void WriteMeshInformation() override;

  void Write() override;

  void WritePoints( void * buffer ) override;

  void WriteCells(void *buffer) override;

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

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

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

  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:
  std::ofstream   m_OutputStream;  // output file
  std::ifstream   m_InputStream;   // input file

  std::string     m_InputLine;     // helper during reading

  using PointValueType = float; // type to represent point coordinates

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

  using PointContainerType = std::vector< PointType >;

  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];
    }
  };

  using PointsMapType = std::map< PointType, IdentifierType, PointCompare >;

  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;

  using CellsVectorType = std::vector< TripletType >;
  CellsVectorType                       m_CellsVector;

};
} // end namespace itk

#endif // itkSTLMeshIO_h