itkInvariantPointCalibrationCostFunction.h

Go to the documentation of this file.

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

  NifTK: A software platform for medical image computing.

  Copyright (c) University College London (UCL). 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 in the top level directory for details.

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

#ifndef itkInvariantPointCalibrationCostFunction_h
#define itkInvariantPointCalibrationCostFunction_h

#include <itkMultipleValuedCostFunction.h>
#include <cv.h>
#include <mitkPoint.h>
#include <mitkVector.h>
#include <mitkTimeStampsContainer.h>
#include <mitkTrackingAndTimeStampsContainer.h>

namespace itk {

class InvariantPointCalibrationCostFunction : public itk::MultipleValuedCostFunction
{

public:

  typedef InvariantPointCalibrationCostFunction Self;
  typedef itk::MultipleValuedCostFunction       Superclass;
  typedef itk::SmartPointer<Self>               Pointer;
  typedef itk::SmartPointer<const Self>         ConstPointer;

  typedef Superclass::ParametersType            ParametersType;
  typedef Superclass::DerivativeType            DerivativeType;
  typedef Superclass::MeasureType               MeasureType;
  typedef mitk::TimeStampsContainer::TimeStamp  TimeStampType;

  itkSetMacro(InvariantPoint, mitk::Point3D);
  itkGetConstMacro(InvariantPoint, mitk::Point3D);

  itkSetMacro(OptimiseInvariantPoint, bool);
  itkGetConstMacro(OptimiseInvariantPoint, bool);

  itkSetMacro(TimingLag, double);
  itkGetConstMacro(TimingLag, double);
  
  itkSetMacro(AllowableTimingError, TimeStampType);
  itkGetConstMacro(AllowableTimingError, TimeStampType);

  itkSetMacro(OptimiseTimingLag, bool);
  itkGetConstMacro(OptimiseTimingLag, bool);

  itkSetMacro(OptimiseRigidTransformation, bool);
  itkGetConstMacro(OptimiseRigidTransformation, bool);

  itkSetMacro(Verbose, bool);
  itkGetConstMacro(Verbose, bool);

  void SetRigidTransformation(const cv::Matx44d& rigidBodyTrans);
  cv::Matx44d GetRigidTransformation() const;

  std::vector<double> GetRigidTransformationParameters() const;
  void SetRigidTransformationParameters(const std::vector<double>& params);

  virtual unsigned int GetNumberOfValues(void) const override;

  virtual unsigned int GetNumberOfParameters() const override;

  void SetNumberOfParameters(const int& numberOfParameters);

  virtual void GetDerivative( const ParametersType & parameters, DerivativeType  & derivative ) const override;

  void SetScales(const ParametersType& scales);

  double GetResidual(const MeasureType& values) const;

  void SetTrackingData(mitk::TrackingAndTimeStampsContainer* trackingData);

  void SetPointData(std::vector< std::pair<unsigned long long, cv::Point3d> >* pointData);

  virtual MeasureType GetValue( const ParametersType & parameters ) const override;

protected:

  InvariantPointCalibrationCostFunction();
  virtual ~InvariantPointCalibrationCostFunction();

  InvariantPointCalibrationCostFunction(const InvariantPointCalibrationCostFunction&); // Purposefully not implemented.
  InvariantPointCalibrationCostFunction& operator=(const InvariantPointCalibrationCostFunction&); // Purposefully not implemented.

  void ValidateSizeOfParametersArray(const ParametersType & parameters) const;

  void ValidateSizeOfScalesArray(const ParametersType & parameters) const;

  virtual cv::Matx44d GetCalibrationTransformation(const ParametersType & parameters) const = 0;

  cv::Matx44d GetRigidTransformation(const ParametersType & parameters) const;

  cv::Matx44d GetTranslationTransformation(const ParametersType & parameters) const;

  double GetLag(const ParametersType & parameters) const;

  ParametersType                                        m_Scales;
  mitk::Point3D                                         m_InvariantPoint;
  bool                                                  m_OptimiseInvariantPoint;
  double                                                m_TimingLag; //in seconds
  bool                                                  m_OptimiseTimingLag;
  std::vector<double>                                   m_RigidTransformation;
  bool                                                  m_OptimiseRigidTransformation;
  mutable unsigned int                                  m_NumberOfValues;
  TimeStampType                                         m_AllowableTimingError;
  unsigned int                                          m_NumberOfParameters;
  std::vector< std::pair<TimeStampType, cv::Point3d> > *m_PointData;
  mitk::TrackingAndTimeStampsContainer                 *m_TrackingData;
  bool                                                  m_Verbose;
};

} // end namespace

#endif