mitkWeightedPointTransform.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 mitkWeightedPointTransform_h
#define mitkWeightedPointTransform_h
 
// EXPORTS
#include <MitkAlgorithmsExtExports.h>
 
// ITK
#include <itkMatrix.h>
#include <itkVariableSizeMatrix.h>
#include <mitkCommon.h>
#include <mitkPointSet.h>
#include <vector>
#include <vtkSmartPointer.h>
 
// forward declarations
class vtkPoints;
class vtkLandmarkTransform;
 
namespace mitk
{
  class MITKALGORITHMSEXT_EXPORT WeightedPointTransform : public itk::Object
  {
    typedef itk::Matrix<double, 3, 3> Matrix3x3;
    typedef Matrix3x3 WeightMatrix;
    typedef Matrix3x3 Rotation;
    typedef itk::Vector<double, 3> Translation;
    typedef std::vector<WeightMatrix> WeightMatrixList;
    typedef std::vector<Matrix3x3> CovarianceMatrixList;
 
  public:
    mitkClassMacroItkParent(WeightedPointTransform, itk::Object);
    itkFactorylessNewMacro(Self);
    itkCloneMacro(Self);
 
      void ComputeTransformation();
 
    itkSetMacro(Threshold, double);
 
      itkSetMacro(MaxIterations, double);
 
      itkGetMacro(Iterations, int);
 
    itkGetMacro(FRE, double);
 
    itkSetMacro(FRENormalizationFactor, double);
 
    itkGetMacro(FRENormalizationFactor, double);
 
    void SetMovingPointSet(vtkSmartPointer<vtkPoints> p);
 
    void SetCovarianceMatricesMoving(const CovarianceMatrixList &matrices);
 
    void SetFixedPointSet(vtkSmartPointer<vtkPoints> p);
 
    void SetCovarianceMatricesFixed(const CovarianceMatrixList &matrices);
 
    const Translation &GetTransformT() const { return m_Translation; }
    const Rotation &GetTransformR() const { return m_Rotation; }
  protected:
    WeightedPointTransform();
    ~WeightedPointTransform() override;
 
    double m_Threshold;
 
    int m_MaxIterations;
 
    int m_Iterations;
 
    double m_FRE;
 
    double m_FRENormalizationFactor;
 
    vtkSmartPointer<vtkLandmarkTransform> m_LandmarkTransform;
 
    vtkSmartPointer<vtkPoints> m_FixedPointSet;
 
    vtkSmartPointer<vtkPoints> m_MovingPointSet;
 
    CovarianceMatrixList m_CovarianceMatricesMoving;
 
    CovarianceMatrixList m_CovarianceMatricesFixed;
 
    Translation m_Translation;
 
    Rotation m_Rotation;
 
    void C_maker(vtkPoints *X, const WeightMatrixList &W, itk::VariableSizeMatrix<double> &returnValue);
 
    void E_maker(vtkPoints *X, vtkPoints *Y, const WeightMatrixList &W, vnl_vector<double> &returnValue);
 
    double CalculateConfigChange(vtkPoints *X, vtkPoints *X_new);
 
    void WeightedPointRegister(vtkPoints *X,
                               vtkPoints *Y,
                               const CovarianceMatrixList &Sigma_X,
                               const CovarianceMatrixList &Sigma_Y,
                               double Threshold,
                               int MaxIterations,
                               Rotation &TransformationR,
                               Translation &TransformationT,
                               double &FRE,
                               int &n);
  };
}
#endif