niftkNiftyCalVideoCalibrationManager.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 niftkNiftyCalVideoCalibrationManager_h
#define niftkNiftyCalVideoCalibrationManager_h

#include "niftkNiftyCalExports.h"
#include <itkObject.h>
#include <itkObjectFactoryBase.h>
#include <mitkDataStorage.h>
#include <mitkDataNode.h>
#include <mitkPointSet.h>
#include <niftkPointUtilities.h>
#include <niftkIPoint2DDetector.h>
#include <cv.h>
#include <list>

namespace niftk
{

class NIFTKNIFTYCAL_EXPORT NiftyCalVideoCalibrationManager : public itk::Object
{
public:

  enum CalibrationPatterns
  {
    // Order must match that in niftk::CameraCalViewPreferencePage
    CHESS_BOARD,
    CIRCLE_GRID,
    APRIL_TAGS,
    TEMPLATE_MATCHING_CIRCLES,
    TEMPLATE_MATCHING_RINGS
  };

  enum HandEyeMethod
  {
    // Order must match that in niftk::CameraCalViewPreferencePage
    TSAI_1989,
    SHAHIDI_2002,
    MALTI_2013,
    NON_LINEAR_EXTRINSIC
  };

  const static bool                DefaultDoIterative;
  const static bool                DefaultDo3DOptimisation;
  const static unsigned int        DefaultMinimumNumberOfSnapshotsForCalibrating;
  const static double              DefaultScaleFactorX;
  const static double              DefaultScaleFactorY;
  const static unsigned int        DefaultGridSizeX;
  const static unsigned int        DefaultGridSizeY;
  const static CalibrationPatterns DefaultCalibrationPattern;
  const static HandEyeMethod       DefaultHandEyeMethod;
  const static std::string         DefaultTagFamily;
  const static unsigned int        DefaultMinimumNumberOfPoints;
  const static bool                DefaultUpdateNodes;

  mitkClassMacroItkParent(NiftyCalVideoCalibrationManager, itk::Object);
  itkNewMacro(NiftyCalVideoCalibrationManager);

  void SetDataStorage(const mitk::DataStorage::Pointer storage);

  void SetLeftImageNode(mitk::DataNode::Pointer node);
  mitk::DataNode::Pointer GetLeftImageNode() const;

  void SetRightImageNode(mitk::DataNode::Pointer node);
  mitk::DataNode::Pointer GetRightImageNode() const;

  void SetTrackingTransformNode(mitk::DataNode::Pointer node);
  itkGetMacro(TrackingTransformNode, mitk::DataNode::Pointer);

  itkSetMacro(ReferenceTrackingTransformNode, mitk::DataNode::Pointer);
  itkGetMacro(ReferenceTrackingTransformNode, mitk::DataNode::Pointer);

  itkSetMacro(MinimumNumberOfSnapshotsForCalibrating, unsigned int);
  itkGetMacro(MinimumNumberOfSnapshotsForCalibrating, unsigned int);

  itkSetMacro(DoIterative, bool);
  itkGetMacro(DoIterative, bool);

  itkSetMacro(Do3DOptimisation, bool);
  itkGetMacro(Do3DOptimisation, bool);

  itkSetMacro(UpdateNodes, bool);
  itkGetMacro(UpdateNodes, bool);

  itkSetMacro(ScaleFactorX, double);
  itkGetMacro(ScaleFactorX, double);

  itkSetMacro(ScaleFactorY, double);
  itkGetMacro(ScaleFactorY, double);

  itkSetMacro(GridSizeX, unsigned int);
  itkGetMacro(GridSizeX, unsigned int);

  itkSetMacro(GridSizeY, unsigned int);
  itkGetMacro(GridSizeY, unsigned int);

  itkSetMacro(MinimumNumberOfPoints, unsigned int);
  itkGetMacro(MinimumNumberOfPoints, unsigned int);

  itkSetMacro(CalibrationPattern, CalibrationPatterns);
  itkGetMacro(CalibrationPattern, CalibrationPatterns);

  itkSetMacro(HandeyeMethod, HandEyeMethod);
  itkGetMacro(HandeyeMethod, HandEyeMethod);

  itkSetMacro(TagFamily, std::string);
  itkGetMacro(TagFamily, std::string);

  void SetModelFileName(const std::string& fileName);
  itkGetMacro(ModelFileName, std::string);

  void SetOutputDirName(const std::string& dirName);
  itkGetMacro(OutputDirName, std::string);

  void SetReferenceDataFileNames(const std::string& imageFileName,
                                 const std::string& pointsFileName);
  itkGetMacro(ReferenceImageFileName, std::string);
  itkGetMacro(ReferencePointsFileName, std::string);

  void SetTemplateImageFileName(const std::string& fileName);
  itkGetMacro(TemplateImageFileName, std::string);

  void SetModelToTrackerFileName(const std::string& fileName);
  itkGetMacro(ModelToTrackerFileName, std::string);

  unsigned int GetNumberOfSnapshots() const;

  void Restart();

  bool Grab();

  void UnGrab();

  double Calibrate();

  void Save();

  void UpdateCameraToWorldPosition();

  void LoadCalibrationFromDirectory(const std::string& dirName);

protected:

  NiftyCalVideoCalibrationManager(); // Purposefully hidden.
  virtual ~NiftyCalVideoCalibrationManager(); // Purposefully hidden.

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

private:

  void ConvertImage(mitk::DataNode::Pointer imageNode, cv::Mat& outputImage);

  bool ExtractPoints(int imageIndex, const cv::Mat& image);

  std::list<cv::Matx44d> ExtractCameraMatrices(int imageIndex);

  std::list<cv::Matx44d> ExtractTrackingMatrices(bool useReference);

  std::vector<cv::Mat> ConvertMatrices(const std::list<cv::Matx44d>& list);

  cv::Matx44d DoTsaiHandEye(int imageIndex, bool useReference);

  cv::Matx44d DoShahidiHandEye(int imageIndex, bool useReference);

  cv::Matx44d DoMaltiHandEye(int imageIndex, bool useReference);

  cv::Matx44d DoFullExtrinsicHandEye(int imageIndex, bool useReference);

  void DoFullExtrinsicHandEyeInStereo(cv::Matx44d& leftHandEye, cv::Matx44d& rightHandEye, bool useReference);

  void UpdateVisualisedPoints(cv::Matx44d& transform);

  void SaveImages(const std::string& prefix,
                  const std::list<std::pair<std::shared_ptr<niftk::IPoint2DDetector>, cv::Mat> >&
                  );

  void SavePoints(const std::string& prefix, const std::list<niftk::PointSet>& points);

  void SetIntrinsicsOnImage(const cv::Mat& intrinsics,
                            const cv::Mat& distortion,
                            const std::string& propertyName,
                            mitk::DataNode::Pointer image);

  void SetStereoExtrinsicsOnImage(const cv::Mat& leftToRightRotationMatrix,
                                  const cv::Mat& leftToRightTranslationVector,
                                  const std::string& propertyName,
                                  mitk::DataNode::Pointer image
                                  );

  void UpdateDisplayNodes();

  typedef mitk::GenericProperty<itk::Matrix<float, 4, 4> > MatrixProperty;

  // Data from Plugin/DataStorage.
  mitk::DataStorage::Pointer                     m_DataStorage;
  mitk::DataNode::Pointer                        m_ImageNode[2];
  mitk::DataNode::Pointer                        m_TrackingTransformNode;
  mitk::DataNode::Pointer                        m_ReferenceTrackingTransformNode;

  // Data from preferences.
  bool                                           m_DoIterative;
  bool                                           m_Do3DOptimisation;
  unsigned int                                   m_MinimumNumberOfSnapshotsForCalibrating;
  std::string                                    m_ModelFileName;
  double                                         m_ScaleFactorX;
  double                                         m_ScaleFactorY;
  unsigned int                                   m_GridSizeX;
  unsigned int                                   m_GridSizeY;
  CalibrationPatterns                            m_CalibrationPattern;
  HandEyeMethod                                  m_HandeyeMethod;
  std::string                                    m_TagFamily;
  std::string                                    m_OutputDirName;
  std::string                                    m_ModelToTrackerFileName;
  std::string                                    m_ReferenceImageFileName;
  std::string                                    m_ReferencePointsFileName;
  bool                                           m_UpdateNodes;
  unsigned int                                   m_MinimumNumberOfPoints;
  std::string                                    m_TemplateImageFileName;
  std::string                                    m_CalibrationDirName;

  // Data used for temporary storage
  cv::Mat                                        m_TmpImage[2];

  // Data used for calibration.
  cv::Size2i                                     m_ImageSize;
  std::pair< cv::Mat, niftk::PointSet>           m_ReferenceDataForIterativeCalib;
  cv::Mat                                        m_TemplateImage;
  cv::Matx44d                                    m_ModelToTracker;
  niftk::Model3D                                 m_ModelPoints;
  mitk::PointSet::Pointer                        m_ModelPointsToVisualise;
  mitk::DataNode::Pointer                        m_ModelPointsToVisualiseDataNode;
  std::list<niftk::PointSet>                     m_Points[2];
  std::list<
    std::pair<
      std::shared_ptr<niftk::IPoint2DDetector>,
      cv::Mat>
    >                                            m_OriginalImages[2];
  std::list<
    std::pair<
      std::shared_ptr<niftk::IPoint2DDetector>,
      cv::Mat>
    >                                            m_ImagesForWarping[2];
  std::list<cv::Matx44d>                         m_TrackingMatrices;
  std::vector<mitk::DataNode::Pointer>           m_TrackingMatricesDataNodes;
  std::list<cv::Matx44d>                         m_ReferenceTrackingMatrices;

  // Calibration result
  cv::Mat                                        m_Intrinsic[2];
  cv::Mat                                        m_Distortion[2];
  std::vector<cv::Mat>                           m_Rvecs[2];
  std::vector<cv::Mat>                           m_Tvecs[2];
  cv::Mat                                        m_EssentialMatrix;
  cv::Mat                                        m_FundamentalMatrix;
  cv::Mat                                        m_LeftToRightRotationMatrix;
  cv::Mat                                        m_LeftToRightTranslationVector;
  std::vector<cv::Matx44d>                       m_HandEyeMatrices[2];
  std::vector<cv::Matx44d>                       m_ReferenceHandEyeMatrices[2];
  cv::Matx44d                                    m_ModelToWorld;

}; // end class

} // end namespace

#endif