niftkMeshSmoother.h

Go to the documentation of this file.

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

  NifTK: A software platform for medical image computing.

  Copyright (c) University College London (UCL). All rights reserved.

  This software is distributed WITHOUT ANY WARRANTY; without even
  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  PURPOSE.

  See LICENSE.txt in the top level directory for details.

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

#ifndef niftkMeshSmoother_h
#define niftkMeshSmoother_h

#include <mitkLogMacros.h>

#include <iostream>
#include <vector>
#include "niftkBasicVertex.h"
#include "niftkBasicTriangle.h"
#include "niftkCMC33.h"

#include "niftkCoreExports.h"

#include <iostream>
using std::cout;
using std::endl;

#include <fstream>
using std::ifstream;
using std::ofstream;

#include <iomanip>
using std::setiosflags;

#include <ios>
using std::ios_base;
using std::ios;

#include <set>
#include <vector>

#include <limits>
using std::numeric_limits;

#include <cstring> // for memcpy()
#include <cctype>

namespace niftk
{

class ordered_size_t_pair
{
public:
  ordered_size_t_pair(const size_t &a, const size_t &b)
  {
    if(a < b)
    {
      indices[0] = a;
      indices[1] = b;
    }
    else
    {
      indices[0] = b;
      indices[1] = a;
    }
  }

  bool operator<(const ordered_size_t_pair &right) const
  {
    if(indices[0] < right.indices[0])
      return true;
    else if(indices[0] > right.indices[0])
      return false;

    if(indices[1] < right.indices[1])
      return true;
    else if(indices[1] > right.indices[1])
      return false;

    return false;
  }

  size_t indices[2];
};

class ordered_indexed_edge
{
public:
  ordered_indexed_edge(const BasicVertex &a, const BasicVertex &b)
  {
    if(a.GetIndex() < b.GetIndex())
    {
      indices[0] = a.GetIndex();
      indices[1] = b.GetIndex();
    }
    else
    {
      indices[0] = b.GetIndex();
      indices[1] = a.GetIndex();
    }

    centre_point.SetX((a.GetCoordX() + b.GetCoordX())*0.5f);
    centre_point.SetY((a.GetCoordY() + b.GetCoordY())*0.5f);
    centre_point.SetZ((a.GetCoordZ() + b.GetCoordZ())*0.5f);
  }

  bool operator<(const ordered_indexed_edge &right) const
  {
    if(indices[0] < right.indices[0])
      return true;
    else if(indices[0] > right.indices[0])
      return false;

    if(indices[1] < right.indices[1])
      return true;
    else if(indices[1] > right.indices[1])
      return false;

    return false;
  }

  size_t indices[2];
  BasicVec3D centre_point;
  size_t id;
};


class NIFTKCORE_EXPORT MeshSmoother
{
public:
  MeshSmoother();
  virtual ~MeshSmoother();

  void Clear(void);

  void InitWithExternalData(MeshData * data);

  void GenerateVertexAndTriangleNormals(void);
  void ReOrientFaces(void);

  bool LoadFromBinarySTL(const char *const file_name, const bool generate_normals = true, const size_t buffer_width = 65536);

  void SetMaxExtent(float max_extent);

  void RescaleMesh(double scale_value);

  void TaubinSmooth(const float lambda, const float mu, const size_t steps);
  void FixCracks(void);

  inline void SetSmoothingMethod(int val) { m_SmoothingMethod = val;}

  inline void SetFlipNormals(bool val) { m_FlipNormals = val;}
  inline bool GetFlipNormals(void) { return m_FlipNormals; }

private:
  void LaplaceSmooth(const float scale);
  void CurvatureNormalSmooth(const float scale);
  void InverseEdgeLengthSmooth(const float scale);

  void GenerateVertexNormals(void);
  void GenerateTriangleNormals(void);
  void RegenerateVertexAndTriangleNormalsIfExists(void);

  template<typename T> void EliminateVectorDuplicates(std::vector<T> &v);
  bool MergeVertexPair(const size_t keeper, const size_t goner);

private:
  int  m_SmoothingMethod; // Stores which smoothing method to use
  bool m_FlipNormals;     // Flag to indicate wether we need to flip the normals

  std::vector<BasicVec3D>   m_VertexNormals;   // stores all vertex normals
  std::vector<BasicVec3D>   m_TriangleNormals; // stores all triangle normals

  MeshData* m_MeshDataExt;  // pointer to the externally created container
};

}

#endif