vtkPlusTemporalCalibrationAlgo.h

Go to the documentation of this file.

/*=Plus=header=begin======================================================
  Program: Plus
  Copyright (c) Laboratory for Percutaneous Surgery. All rights reserved.
  See License.txt for details.
=========================================================Plus=header=end*/

#ifndef _TEMPORAL_CALIBRATION_H
#define _TEMPORAL_CALIBRATION_H

#include "PlusConfigure.h"
#include "vtkPlusCalibrationExport.h"

#include <deque>

#include "vtkObject.h"

//class igsioTrackedFrame; 
class vtkPiecewiseFunction;
class vtkTable;
//class vtkIGSIOTrackedFrameList;

class vtkPlusCalibrationExport vtkPlusTemporalCalibrationAlgo : public vtkObject
{
public:
  vtkTypeMacro(vtkPlusTemporalCalibrationAlgo, vtkObject);
  static vtkPlusTemporalCalibrationAlgo* New();

public:
  enum TEMPORAL_CALIBRATION_ERROR
  {
    TEMPORAL_CALIBRATION_ERROR_NONE,
    TEMPORAL_CALIBRATION_ERROR_RESULT_ABOVE_THRESHOLD,
    TEMPORAL_CALIBRATION_ERROR_INVALID_TRANSFORM_NAME,
    TEMPORAL_CALIBRATION_ERROR_NO_TIMESTAMPS,
    TEMPORAL_CALIBRATION_ERROR_UNABLE_NORMALIZE_METRIC,
    TEMPORAL_CALIBRATION_ERROR_CORRELATION_RESULT_EMPTY,
    TEMPORAL_CALIBRATION_ERROR_NO_VIDEO_DATA,
    TEMPORAL_CALIBRATION_ERROR_NOT_MF_ORIENTATION,
    TEMPORAL_CALIBRATION_ERROR_NOT_ENOUGH_FIXED_FRAMES,
    TEMPORAL_CALIBRATION_ERROR_NO_FRAMES_IN_ULTRASOUND_DATA,
    TEMPORAL_CALIBRATION_ERROR_SAMPLING_RESOLUTION_TOO_SMALL,
    TEMPORAL_CALIBRATION_ERROR_FAILED_COMPUTE_FIXED,
    TEMPORAL_CALIBRATION_ERROR_FAILED_COMPUTE_MOVING,
    TEMPORAL_CALIBRATION_ERROR_NO_COMMON_TIME_RANGE,
  };

  enum FRAME_TYPE
  {
    FRAME_TYPE_NONE,
    FRAME_TYPE_TRACKER, // The tracked frame list contains tracker data
    FRAME_TYPE_VIDEO    // The tracked frame list contains US video data of a plane
    // (e.g., bottom of water tank)
  };

  struct SignalType
  {
    vtkIGSIOTrackedFrameList* frameList;
    FRAME_TYPE frameType;
    std::string probeToReferenceTransformName;
    std::deque<double> signalValues;
    std::deque<double> signalTimestamps;
    std::deque<double> normalizedSignalValues;
    std::deque<double> normalizedSignalTimestamps;
    double signalTimeRangeMin;
    double signalTimeRangeMax;
  };

  PlusStatus ReadConfiguration(vtkXMLDataElement* aConfig);

  void SetSamplingResolutionSec(double samplingResolutionSec);

  void SetFixedFrames(vtkIGSIOTrackedFrameList* frameList, FRAME_TYPE frameType);

  void SetFixedProbeToReferenceTransformName(const std::string& probeToReferenceTransformName);

  void SetMovingFrames(vtkIGSIOTrackedFrameList* frameList, FRAME_TYPE frameType);

  void SetMovingProbeToReferenceTransformName(const std::string& probeToReferenceTransformName);

  void SetMaximumMovingLagSec(double maxLagSec);

  void SetSaveIntermediateImages(bool saveIntermediateImages);

  void SetIntermediateFilesOutputDirectory(const std::string& outputDirectory);

  void SetVideoClipRectangle(int* clipRectOriginIntVec, int* clipRectSizeIntVec);
  std::vector<int> GetVideoClipRectangle() const;

  PlusStatus Update(TEMPORAL_CALIBRATION_ERROR& error);

  PlusStatus GetMovingLagSec(double& lag);

  PlusStatus GetCalibrationError(double& error);

  PlusStatus GetUncalibratedMovingPositionSignal(vtkTable* unCalibratedMovingPositionSignal);
  PlusStatus GetCalibratedMovingPositionSignal(vtkTable* calibratedMovingPositionSignal);
  PlusStatus GetFixedPositionSignal(vtkTable* fixedPositionSignal);
  PlusStatus GetCorrelationSignal(vtkTable* correlationSignal);
  PlusStatus GetCorrelationSignalFine(vtkTable* correlationSignal);

  PlusStatus GetBestCorrelation(double& videoCorrelation);
  PlusStatus GetMaxCalibrationError(double& maxCalibrationError);

protected:
  PlusStatus ComputeMovingSignalLagSec(TEMPORAL_CALIBRATION_ERROR& error);
  PlusStatus ComputePositionSignalValues(SignalType& signal);
  PlusStatus GetSignalRange(const std::deque<double>& signal, int startIndex, int stopIndex, double& minValue, double& maxValue);

  PlusStatus ComputeCommonTimeRange();

  PlusStatus NormalizeMetricValues(std::deque<double>& signal, double& normalizationFactor, int startIndex = 0, int stopIndex = -1);
  PlusStatus NormalizeMetricValues(std::deque<double>& signal, double& normalizationFactor, double startTime, double stopTime, const std::deque<double>& timestamps);
  void ComputeCorrelationBetweenFixedAndMovingSignal(double minTrackerLagSec, double maxTrackerLagSec, double stepSizeSec, double& bestCorrelationValue, double& bestCorrelationTimeOffset, double& bestCorrelationNormalizationFactor, std::deque<double>& corrTimeOffsets, std::deque<double>& corrValues);

  double ComputeAlignmentMetric(const std::deque<double>& signalA, const std::deque<double>& signalB);

  PlusStatus ConstructTableSignal(std::deque<double>& x, std::deque<double>& y, vtkTable* table, double timeCorrection);

  PlusStatus ResampleSignalLinearly(const std::deque<double>& templateSignalTimestamps, const vtkSmartPointer<vtkPiecewiseFunction>& signalFunction, std::deque<double>& resampledSignalValues);

protected:
  SignalType FixedSignal;
  SignalType MovingSignal;

  bool TrackerLagUpToDate;
  bool NeverUpdated;

  bool SaveIntermediateImages;
  std::string IntermediateFilesOutputDirectory;

  double SamplingResolutionSec;

  std::deque<double> CorrelationValues;
  std::deque<double> CorrelationTimeOffsets;

  std::deque<double> CorrelationValuesFine;
  std::deque<double> CorrelationTimeOffsetsFine;

  double BestCorrelationValue;
  double BestCorrelationLagIndex;
  double BestCorrelationTimeOffset;

  std::deque<double> CalibrationErrorVector;

  double MovingLagSec;

  double CalibrationError;
  double MaxCalibrationError;

  double MaxMovingLagSec;

  double BestCorrelationNormalizationFactor;
  double FixedSignalValuesNormalizationFactor;

  int LineSegmentationClipRectangleOrigin[2];

  int LineSegmentationClipRectangleSize[2];

private:
  vtkPlusTemporalCalibrationAlgo();
  ~vtkPlusTemporalCalibrationAlgo();
};


#endif // _TEMPORAL_CALIBRATION_H