mitkWeightedPointTransform.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 __WEIGHTEDPOINTTRANSFORM_H__
#define __WEIGHTEDPOINTTRANSFORM_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();

    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