vtkPlusProbeCalibrationAlgo.h

Go to the documentation of this file.

#ifndef __vtkPlusProbeCalibrationAlgo_h
#define __vtkPlusProbeCalibrationAlgo_h

#include "vtkPlusCalibrationExport.h"

#include <string>
#include <vector>
#include <set>

#include <vnl/vnl_double_3.h>

#include "vtkObject.h"
#include "vtkPlusProbeCalibrationOptimizerAlgo.h"

//class igsioTrackedFrame; 
//class vtkIGSIOTrackedFrameList;
//class vtkIGSIOTransformRepository;
class vtkXMLDataElement;
class PlusNWire;

class vtkPlusCalibrationExport vtkPlusProbeCalibrationAlgo : public vtkObject
{
public:
  static vtkPlusProbeCalibrationAlgo* New();
  vtkTypeMacro( vtkPlusProbeCalibrationAlgo, vtkObject );
  virtual void PrintSelf( ostream& os, vtkIndent indent );

  PlusStatus ReadConfiguration( vtkXMLDataElement* aConfig );

  vtkGetStringMacro( ImageCoordinateFrame );
  vtkGetStringMacro( ProbeCoordinateFrame );
  vtkGetStringMacro( PhantomCoordinateFrame );
  vtkGetStringMacro( ReferenceCoordinateFrame );


  PlusStatus Calibrate( vtkIGSIOTrackedFrameList* validationTrackedFrameList, int validationStartFrame, int validationEndFrame, vtkIGSIOTrackedFrameList* calibrationTrackedFrameList, int calibrationStartFrame, int calibrationEndFrame, vtkIGSIOTransformRepository* transformRepository, const std::vector<PlusNWire>& nWires );

  PlusStatus Calibrate( vtkIGSIOTrackedFrameList* validationTrackedFrameList, vtkIGSIOTrackedFrameList* calibrationTrackedFrameList, vtkIGSIOTransformRepository* transformRepository, const std::vector<PlusNWire>& nWires );

  void GetImageToProbeTransformMatrix( vtkMatrix4x4* imageToProbeMatrix );

  vtkSetStringMacro( CalibrationDate );
  vtkGetStringMacro( CalibrationDate );

  double GetCalibrationReprojectionError3DMean();
  double GetCalibrationReprojectionError3DStdDev();

  double GetValidationReprojectionError3DMean();
  double GetValidationReprojectionError3DStdDev();

  PlusStatus GetCalibrationReport( std::vector<double>* calibError, std::vector<double>* validError, vnl_matrix_fixed<double, 4, 4>* imageToProbeTransformMatrix );

  std::string GetResultString( int precision = 3 );

  PlusStatus GetXMLCalibrationResultAndErrorReport( vtkIGSIOTrackedFrameList* validationTrackedFrameList, int validationStartFrame,
      int validationEndFrame, vtkIGSIOTrackedFrameList* calibrationTrackedFrameList, int calibrationStartFrame, int calibrationEndFrame, vtkXMLDataElement* probeCalibrationResult );

  vtkPlusProbeCalibrationOptimizerAlgo* GetOptimizer()
  {
    return this->Optimizer;
  };

  void ComputeError2d( const vnl_matrix_fixed<double, 4, 4>& imageToProbeMatrix, double& errorMean, double& errorStDev, double& errorRms );
  void ComputeError3d( const vnl_matrix_fixed<double, 4, 4>& imageToProbeMatrix, double& errorMean, double& errorStDev, double& errorRms );

protected:

  enum PreProcessedWirePositionIdType
  {
    CALIBRATION_ALL = 0,
    VALIDATION_ALL,
    CALIBRATION_NOT_OUTLIER,
    LAST_PREPROCESSED_WIRE_POS_ID // this must be the last type
  };

  void ComputeError3d( std::vector<double>& reprojectionErrors, PreProcessedWirePositionIdType datasetType, const vnl_matrix_fixed<double, 4, 4>& imageToProbeMatrix );

  void ComputeError2d( PreProcessedWirePositionIdType datasetType, const vnl_matrix_fixed<double, 4, 4>& imageToProbeMatrix,
                       double& errorMean, double& errorStDev, double& errorRms,
                       std::vector< std::vector< vnl_vector_fixed<double, 2> > >* ReprojectionError2Ds = NULL );

  PlusStatus AddPositionsPerImage( igsioTrackedFrame* trackedFrame, vtkIGSIOTransformRepository* transformRepository, PreProcessedWirePositionIdType datasetType );

  PlusStatus ComputeReprojectionErrors3D( PreProcessedWirePositionIdType datasetType, const vnl_matrix_fixed<double, 4, 4>& imageToProbeTransformMatrix );

  PlusStatus ComputeReprojectionErrors2D( PreProcessedWirePositionIdType datasetType, const vnl_matrix_fixed<double, 4, 4>& imageToProbeTransformMatrix );

  void SetAndValidateImageToProbeTransform( const vnl_matrix_fixed<double, 4, 4>& imageToProbeTransformMatrix, vtkIGSIOTransformRepository* transformRepository );

  PlusStatus SaveCalibrationResultAndErrorReportToXML( vtkIGSIOTrackedFrameList* validationTrackedFrameList, int validationStartFrame, int validationEndFrame, vtkIGSIOTrackedFrameList* calibrationTrackedFrameList, int calibrationStartFrame, int calibrationEndFrame );

  PlusStatus ComputeImageToProbeTransformByLinearLeastSquaresMethod( vnl_matrix_fixed<double, 4, 4>& imageToProbeTransformMatrix, std::set<int>& outliers );

  void UpdateNonOutlierData( const std::set<int>& outliers );

  static double PointToWireDistance( const vnl_double_3& aPoint, const vnl_double_3& aLineEndPoint1, const vnl_double_3& aLineEndPoint2 );

protected:
  vtkSetStringMacro( ImageCoordinateFrame );
  vtkSetStringMacro( ProbeCoordinateFrame );
  vtkSetStringMacro( PhantomCoordinateFrame );
  vtkSetStringMacro( ReferenceCoordinateFrame );

protected:
  vtkPlusProbeCalibrationAlgo();
  virtual ~vtkPlusProbeCalibrationAlgo();

protected:
  char* CalibrationDate;

  char* ImageCoordinateFrame;

  char* ProbeCoordinateFrame;

  char* PhantomCoordinateFrame;

  char* ReferenceCoordinateFrame;

  vnl_matrix_fixed<double, 4, 4> ImageToProbeTransformMatrix;

  std::vector<PlusNWire> NWires;

  struct NWirePositionType
  {
    std::vector< vnl_vector_fixed<double, 4> > AllWiresIntersectionPointsPos_Image;
    std::vector< vnl_vector_fixed<double, 4> > MiddleWireIntersectionPointsPos_Probe;

    vnl_matrix_fixed<double, 4, 4> ProbeToPhantomTransform;
  };

  struct NWireErrorType
  {
    std::vector< std::vector<double> > ReprojectionError3Ds;

    std::vector< std::vector< vnl_vector_fixed<double, 2> > > ReprojectionError2Ds;

    std::vector< vnl_vector_fixed<double, 2> > ReprojectionError2DMeans;

    std::vector< vnl_vector_fixed<double, 2> > ReprojectionError2DStdDevs;

    double ReprojectionError3DMean;

    double ReprojectionError3DStdDev;

    double ReprojectionError3DMax;

    double RmsError2D;

    NWireErrorType()
      : ReprojectionError3DMean( -1.0 )
      , ReprojectionError3DStdDev( -1.0 )
      , RmsError2D( -1.0 )
    {}

  };

  struct PreProcessedWirePositionsType
  {
    std::vector<NWirePositionType> FramePositions;
    NWireErrorType NWireErrors;

    void Clear()
    {
      FramePositions.clear();

      NWireErrors.ReprojectionError3Ds.clear();
      NWireErrors.ReprojectionError2Ds.clear();
      NWireErrors.ReprojectionError2DStdDevs.clear();
      NWireErrors.ReprojectionError2DMeans.clear();
    }
  };

  PreProcessedWirePositionsType PreProcessedWirePositions[LAST_PREPROCESSED_WIRE_POS_ID];

  double ErrorConfidenceLevel;

  vtkPlusProbeCalibrationOptimizerAlgo* Optimizer;

private:
  vtkPlusProbeCalibrationAlgo( const vtkPlusProbeCalibrationAlgo& );
  void operator=( const vtkPlusProbeCalibrationAlgo& );
};

#endif //  __vtkPlusProbeCalibrationAlgo_h