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:
    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);
 
    itkBooleanMacro(Smooth);
 
    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