SignUKFRegistration.h

Go to the documentation of this file.

/*=========================================================================

  Program:       TheSIGN
  Module:        SignUKFRegistration.h
  Language:      C++
  Date:          Date: 2006/08/04 10:27:51
  Version:

  Project:       TheSIGN
  Application:   Ventriculoscopy-Navigation  (Beluga (?))
  Author:        Christian Bauer


=========================================================================*/


#ifndef __SignUKFRegistration_h
#define __SignUKFRegistration_h

// includes
#include "vtkPoints.h"
#include "vtkLinearTransform.h"

#include <vtkMatrix4x4.h>
#include <SignFiducialCollection.h>
#include <SignContext.h>
#include <SignUIBase.h>
// defines

// class
//class SignElement;

class SIGN_EXPORT SignUKFRegistration : public vtkLinearTransform
//class SignUKFRegistration : public vtkObject
{

 public:
  //SignUKFRegistration(SignContext* context_);



  vtkTypeRevisionMacro(SignUKFRegistration,vtkLinearTransform);
  void PrintSelf(ostream& os, vtkIndent indent);

  static SignUKFRegistration *New();

  void SetSourcePoints(vtkPoints *sourcepoints);
  void SetTargetPoints(vtkPoints *targetpoints);
  vtkGetObjectMacro(SourcePoints, vtkPoints);
  vtkGetObjectMacro(TargetPoints, vtkPoints);

  vtkMatrix4x4 *RegisterWithUKF(SignFiducialCollection *set1, SignFiducialCollection *set2);

  //vtkMatrix4x4 InternalUpdate();
  void InternalUpdate();
  double HomogenousTransform[4][4];
  // Description:
  // Get the MTime.
  unsigned long GetMTime();

  void SetContext(SignContext*);
  void SetUIBase(SignUIBase*);

  double GetMeanSDError();
  double GetMaxSDError();
  // Description:
  // Invert the transformation.  This is done by switching the
  // source and target landmarks.
  void Inverse();

  // Description:
  // Make another transform of the same type.
  vtkAbstractTransform *MakeTransform();



protected:

  SignUKFRegistration();
  ~SignUKFRegistration();

  SignContext* context;
  SignUIBase* gui;
//   void UKF(double state_vector4ukf[6], double state_covariance4ukf[6][6],
//                             double nearestneighbour_transponated[t][3], double Var_State[6][6],
//                             double MRTPoints4ukf[3][t], double Var_Observ_Diag_3malt[3*t][3*t],
//                             double t, double alpha, double beta, double kappa,
//                             double state_vector[6], double state_covariance[6][6]);
  void UKF(double state_vector4ukf[6], double state_covariance4ukf[6][6],
           double **nearest_neighbours, double Var_State[6][6],
           double **SourcePoints4ukf, double **Var_Observ_Diag_3malt,
           int t, double alpha, double beta, double kappa,
           double state_vector_new[6], double state_covariance_new[6][6]);

//  void HfunReg(double x[6][13], double t, double u[3][t], double y[3*t][13]);
  void HfunReg(double xSigmaPts4HfunReg[6][13], int t, double **nearest_neighbour_transposed, double **zPredSigmaPts);

  void ScaledSymmetricSigmaPts(double xQ[6], double PQ[6][6], double alpha, double beta, double kappa, double xPts[6][13], double wPts[14]);

  void CholeskyFactorization(double matrix2factorize[6][6]);

  void rotateM(double vector2rot[3], double R[3][3]);

  void AllocateMatrix(double**& M, int r, int c);
  void DeallocateMatrix(double **M, int r);
  void PrintMatrix(double **M, int r, int c, const char* name);

  void MultiplyMatrix4UKF(double **A, double **B,
                          unsigned int rowA, unsigned int colA,
                          unsigned int rowB, unsigned int colB,
                          double **C);

  vtkPoints *SourcePoints;
  vtkPoints *TargetPoints;

private:
  SignUKFRegistration(const SignUKFRegistration&);  // Not implemented.
  void operator=(const SignUKFRegistration&);  // Not implemented.

  double mean_squared_dist;
  double max_squared_dist;

};
#endif

---