mitkCreateDistanceImageFromSurfaceFilter.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 mitkCreateDistanceImageFromSurfaceFilter_h
#define mitkCreateDistanceImageFromSurfaceFilter_h
 
#include <MitkSurfaceInterpolationExports.h>
 
#include <mitkImageSource.h>
#include <mitkProgressBar.h>
#include <mitkSurface.h>
 
#include <vnl/vnl_vector_fixed.h>
 
#include <itkImageBase.h>
 
#include <itkeigen/Eigen/Dense>
 
namespace mitk
{
  class MITKSURFACEINTERPOLATION_EXPORT CreateDistanceImageFromSurfaceFilter : public ImageSource
  {
  public:
    typedef vnl_vector_fixed<double, 3> PointType;
 
    typedef itk::Image<double, 3> DistanceImageType;
    typedef DistanceImageType::IndexType IndexType;
 
    typedef std::vector<PointType> NormalList;
    typedef std::vector<PointType> CenterList;
 
    typedef std::vector<Surface::Pointer> SurfaceList;
 
    mitkClassMacro(CreateDistanceImageFromSurfaceFilter, ImageSource);
    itkFactorylessNewMacro(Self);
    itkCloneMacro(Self);
    itkGetMacro(DistanceImageSpacing, double);
 
        using Superclass::SetInput;
 
    // Methods copied from mitkSurfaceToSurfaceFilter
    virtual void SetInput(const mitk::Surface *surface);
 
    virtual void SetInput(unsigned int idx, const mitk::Surface *surface);
 
    virtual const mitk::Surface *GetInput();
 
    virtual const mitk::Surface *GetInput(unsigned int idx);
 
    virtual void RemoveInputs(mitk::Surface *input);
 
    itkSetMacro(DistanceImageVolume, unsigned int);
 
    void PrintEquationSystem();
 
    // Resets the filter, i.e. removes all inputs and outputs
    void Reset();
 
    void SetUseProgressBar(bool);
 
    void SetProgressStepSize(unsigned int stepSize);
 
    void SetReferenceImage(itk::ImageBase<3>::Pointer referenceImage);
 
  protected:
    CreateDistanceImageFromSurfaceFilter();
    ~CreateDistanceImageFromSurfaceFilter() override;
    void GenerateData() override;
    void GenerateOutputInformation() override;
 
  private:
    void CreateSolutionMatrixAndFunctionValues();
    double CalculateDistanceValue(PointType p);
 
    void FillDistanceImage();
 
    void DetermineBounds(DistanceImageType::PointType &minPointInWorldCoordinates,
                         DistanceImageType::PointType &maxPointInWorldCoordinates,
                         DistanceImageType::IndexType &minPointInIndexCoordinates,
                         DistanceImageType::IndexType &maxPointInIndexCoordinates);
 
    void PreprocessContourPoints();
    void CreateEmptyDistanceImage();
 
    // Datastructures for the interpolation
    CenterList m_Centers;
    NormalList m_Normals;
 
    Eigen::MatrixXd m_SolutionMatrix;
    Eigen::VectorXd m_FunctionValues;
    Eigen::VectorXd m_Weights;
 
    DistanceImageType::Pointer m_DistanceImageITK;
    itk::ImageBase<3>::Pointer m_ReferenceImage;
 
    double m_DistanceImageSpacing;
    double m_DistanceImageDefaultBufferValue;
    unsigned int m_DistanceImageVolume;
 
    bool m_UseProgressBar;
    unsigned int m_ProgressStepSize;
  };
 
} // namespace
 
#endif