niftkImageToSurfaceFilter.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 niftkImageToSurfaceFilter_h
#define niftkImageToSurfaceFilter_h

#include "niftkCoreExports.h"

#include <mitkCommon.h>
#include <mitkSurfaceSource.h>
#include <mitkSurface.h>
#include <mitkImage.h>

#include <vtkPolyData.h>
#include <vtkImageData.h>
#include <vtkSmoothPolyDataFilter.h>
#include <vtkMarchingCubes.h>
#include <vtkSmartPointer.h>

#include "niftkBasicVertex.h"
#include "niftkBasicTriangle.h"
#include "niftkCMC33.h"
#include "mitkBasicImageProcessor.h"

namespace niftk
{


class NIFTKCORE_EXPORT ImageToSurfaceFilter : public mitk::SurfaceSource
{
public:

  enum SurfaceExtractionMethod {StandardExtractor, EnhancedCPUExtractor, GPUExtractor};
  enum SurfaceDecimationMethod {NoDecimation, DecimatePro, QuadricVTK, Quadric, QuadricTri, Melax, ShortestEdge};
  enum SurfaceSmoothingMethod  {NoSurfaceSmoothing, TaubinSmoothing, CurvatureNormalSmooth, InverseEdgeLengthSmooth, WindowedSincSmoothing, StandardVTKSmoothing};
  enum InputSmoothingMethod    {NoInputSmoothing, GaussianSmoothing, MedianSmoothing};

  mitkClassMacro(ImageToSurfaceFilter, SurfaceSource)
  itkNewMacro(Self)

  virtual void GenerateData() override;

  virtual void GenerateOutputInformation() override;

  const mitk::Image *GetInput(void);

  using itk::ProcessObject::SetInput;
  virtual void SetInput(const mitk::Image *image);


  itkSetMacro(Threshold, mitk::ScalarType);

  itkGetConstMacro(Threshold, mitk::ScalarType);

  itkGetConstMacro(SurfaceExtractionType, SurfaceExtractionMethod);

  itkSetMacro(SurfaceExtractionType, SurfaceExtractionMethod);



  itkGetConstMacro(InputSmoothingType, InputSmoothingMethod);

  itkSetMacro(InputSmoothingType, InputSmoothingMethod);

  itkSetMacro(PerformInputSmoothing,bool);

  itkBooleanMacro(PerformInputSmoothing);

  itkGetConstMacro(PerformInputSmoothing,bool);

  itkSetMacro(InputSmoothingRadius, float);

  itkGetConstMacro(InputSmoothingRadius, float);

  itkSetMacro(InputSmoothingIterations, int);

  itkGetConstMacro(InputSmoothingIterations, int);



  itkGetConstMacro(SurfaceSmoothingType, SurfaceSmoothingMethod);

  itkSetMacro(SurfaceSmoothingType, SurfaceSmoothingMethod);

  itkSetMacro(PerformSurfaceSmoothing,bool);

  itkBooleanMacro(PerformSurfaceSmoothing);

  itkGetConstMacro(PerformSurfaceSmoothing,bool);

  itkSetMacro(SurfaceSmoothingRadius, float);

  itkGetConstMacro(SurfaceSmoothingRadius, float);

  itkSetMacro(SurfaceSmoothingIterations, int);

  itkGetConstMacro(SurfaceSmoothingIterations, int);



  itkGetConstMacro(SurfaceDecimationType, SurfaceDecimationMethod);

  itkSetMacro(SurfaceDecimationType, SurfaceDecimationMethod);

  itkSetMacro(PerformSurfaceDecimation,bool);

  itkBooleanMacro(PerformSurfaceDecimation);

  itkGetConstMacro(PerformSurfaceDecimation,bool);

  itkSetMacro(TargetReduction, float);

  itkGetConstMacro(TargetReduction, float);

  itkSetMacro(SamplingRatio, double);

  itkGetConstMacro(SamplingRatio, double);


  itkSetMacro(PerformSurfaceCleaning,bool);
  itkGetConstMacro(PerformSurfaceCleaning,bool);

  itkSetMacro(SurfaceCleaningThreshold, int);

  itkGetConstMacro(SurfaceCleaningThreshold, int);


  template <class T1, class T2, class T3>
  inline void mitkVtkLinearTransformPoint(T1 matrix[4][4], T2 in[3], T3 out[3])
  {
    T3 x = matrix[0][0]*in[0]+matrix[0][1]*in[1]+matrix[0][2]*in[2]+matrix[0][3];
    T3 y = matrix[1][0]*in[0]+matrix[1][1]*in[1]+matrix[1][2]*in[2]+matrix[1][3];
    T3 z = matrix[2][0]*in[0]+matrix[2][1]*in[1]+matrix[2][2]*in[2]+matrix[2][3];
    out[0] = x;
    out[1] = y;
    out[2] = z;
  }

protected:

  ImageToSurfaceFilter();

  virtual ~ImageToSurfaceFilter();

  void CreateSurface(mitk::Image *image, mitk::Surface *surface);

  void VTKSurfaceExtraction(mitk::Image *image, vtkSmartPointer<vtkPolyData> vtkSurface);
  void CMC33SurfaceExtraction(mitk::Image *inputImage, MeshData * meshData);

  void MeshSmoothing(MeshData * meshData);

  void SurfaceSmoothingVTK(vtkSmartPointer<vtkPolyData> vtkSurface);
  void ComputeSmoothNormals(MeshData * meshData);

  void EditSurface(MeshData * meshData, bool recomputeNormals, bool flipNormals, bool reorientFaces, bool fixCracks);

  vtkSmartPointer<vtkPolyData> BuildVTKPolyData(MeshData * meshData);

  mitk::ScalarType              m_Threshold;

  SurfaceExtractionMethod m_SurfaceExtractionType;

  InputSmoothingMethod    m_InputSmoothingType;
  bool                    m_PerformInputSmoothing;
  int                     m_InputSmoothingIterations;
  float                   m_InputSmoothingRadius;

  SurfaceSmoothingMethod  m_SurfaceSmoothingType;
  bool                    m_PerformSurfaceSmoothing;
  int                     m_SurfaceSmoothingIterations;
  float                   m_SurfaceSmoothingRadius;

  SurfaceDecimationMethod m_SurfaceDecimationType;
  bool                    m_PerformSurfaceDecimation;
  double                  m_TargetReduction;

  bool                    m_PerformSurfaceCleaning;
  int                     m_SurfaceCleaningThreshold;

  bool                    m_VTKNormalCompute;
  bool                    m_FlipNormals;

  double                  m_SamplingRatio;

};

}

#endif