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_Included
#define mitkCreateDistanceImageFromSurfaceFilter_h_Included

#include <MitkSurfaceInterpolationExports.h>

#include "mitkImageSource.h"
#include "mitkProgressBar.h"
#include "mitkSurface.h"

#include "vnl/vnl_vector_fixed.h"

#include "itkImageBase.h"

#include <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