mitkImageToSurfaceFilter.h

Go to the documentation of this file.

/*============================================================================
 
The Medical Imaging Interaction Toolkit (MITK)
 
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
 
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
 
============================================================================*/
 
#ifndef mitkImageToSurfaceFilter_h
#define mitkImageToSurfaceFilter_h
 
#include "MitkCoreExports.h"
#include <mitkCommon.h>
#include <mitkSurface.h>
#include <mitkSurfaceSource.h>
#include <vtkPolyData.h>
 
#include <mitkImage.h>
#include <vtkImageData.h>
 
#include <vtkMarchingCubes.h>
#include <vtkSmoothPolyDataFilter.h>
 
namespace mitk
{
  class MITKCORE_EXPORT ImageToSurfaceFilter : public SurfaceSource
  {
  public:
    /*
  * To decide whether a reduction of polygons in the created surface shall be
  * done or not by using the vtkDecimatePro Filter. Till vtk 4.x an vtkDecimateFilter existed,
  * but was patented. So since vtk 5.x it was replaced by the (much worse?) vtkDecimateProFilter
  * Maybe another Filter will come soon.
  */
    enum DecimationType
    {
      NoDecimation,
      DecimatePro,
      QuadricDecimation
    };
 
    mitkClassMacro(ImageToSurfaceFilter, SurfaceSource);
    itkFactorylessNewMacro(Self);
    itkCloneMacro(Self);
 
      void GenerateData() override;
 
    void GenerateOutputInformation() override;
 
    const mitk::Image *GetInput(void);
 
    using itk::ProcessObject::SetInput;
    virtual void SetInput(const mitk::Image *image);
 
    void SetSmoothIteration(int smoothIteration);
 
    void SetSmoothRelaxation(float smoothRelaxation);
 
    itkSetMacro(Threshold, ScalarType);
 
    itkGetConstMacro(Threshold, ScalarType);
 
    itkSetMacro(Smooth, bool);
 
    /*
     * Enable/Disable surface smoothing.
     */
    itkBooleanMacro(Smooth);
 
    /*
     * Returns if surface smoothing is enabled
     */
    itkGetConstMacro(Smooth, bool);
 
    itkGetConstMacro(Decimate, DecimationType);
 
    itkSetMacro(Decimate, DecimationType);
 
    itkSetMacro(TargetReduction, float);
 
    itkGetConstMacro(TargetReduction, float);
 
    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();
 
    ~ImageToSurfaceFilter() override;
 
    void CreateSurface(int time, vtkImageData *vtkimage, mitk::Surface *surface, const ScalarType threshold);
 
    bool m_Smooth;
 
    DecimationType m_Decimate;
 
    ScalarType m_Threshold;
 
    float m_TargetReduction;
 
    int m_SmoothIteration;
 
    float m_SmoothRelaxation;
  };
 
} // namespace mitk
 
#endif