mitkImageToSurfaceFilter.h

Go to the documentation of this file.

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

The Medical Imaging Interaction Toolkit (MITK)

Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
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 or http://www.mitk.org for details.

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

#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 (worser?) vtkDecimateProFilter
  * Maybe another Filter will come soon.
  */
    enum DecimationType
    {
      NoDecimation,
      DecimatePro,
      QuadricDecimation
    };

    mitkClassMacro(ImageToSurfaceFilter, SurfaceSource);
    itkFactorylessNewMacro(Self) itkCloneMacro(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);

    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();

    virtual ~ImageToSurfaceFilter();

    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 //_MITKIMAGETOSURFACEFILTER_h__