PlusFidLabeling.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 _FIDUCIAL_LABELLING_H
#define _FIDUCIAL_LABELLING_H

#include "PlusFidPatternRecognitionCommon.h"
#include "PlusConfigure.h"
class vtkXMLDataElement;

class vtkPlusCalibrationExport PlusLabelingResults
{
public:
  int patternId;//Id of the pattern
  int wireId;//Id of the wire in the pattern
  double x, y; //coordinate in the image plane
};

//-----------------------------------------------------------------------------

class vtkPlusCalibrationExport PlusFidLabeling
{
public:
  PlusFidLabeling();
  virtual ~PlusFidLabeling();

  void UpdateParameters();

  void Clear();

  PlusStatus ReadConfiguration(vtkXMLDataElement* rootConfigElement, double minThetaRad, double maxThetaRad);

  void SetFrameSize(const FrameSizeType& frameSize);

  double ComputeDistancePointLine(PlusFidDot& dot, PlusFidLine& line);

  double ComputeShift(PlusFidLine& line1, PlusFidLine& line2);

  double ComputeSlope(PlusFidLine& line);

  void FindPattern();

  void UpdateCirsResults(const PlusFidLine& resultLine1, const PlusFidLine& resultLine2, const PlusFidLine& resultLine3);

  void UpdateNWiresResults(std::vector<PlusFidLine*>& resultLines);

  void SortRightToLeft(PlusFidLine& line);

  static bool SortCompare(const std::vector<double>& temporaryLine1, const std::vector<double>& temporaryLine2);

  PlusFidLine SortPointsByDistanceFromStartPoint(PlusFidLine& fiducials);

  //Accessors and mutators
  std::vector<PlusFidDot>& GetDotsVector() {return m_DotsVector; };

  void SetDotsVector(std::vector<PlusFidDot>& value) { m_DotsVector = value; };

  std::vector<PlusFidLine>& GetFoundLinesVector() {return m_FoundLines; };

  void SetLinesVector(std::vector< std::vector<PlusFidLine> >& value) { m_LinesVector = value; };

  std::vector<PlusFidPattern*>& GetPatterns();

  void SetPatterns(const std::vector<PlusFidPattern*>& value) { m_Patterns = value; };

  double GetPatternIntensity() { return m_PatternIntensity; };

  void SetDotsFound(bool value) { m_DotsFound = value; };

  bool GetDotsFound() { return m_DotsFound; };

  std::vector<std::vector<double>> GetFoundDotsCoordinateValue() { return m_FoundDotsCoordinateValue; };

  std::vector<std::vector<PlusFidLine>>  GetLinesVector() { return m_LinesVector; };

  void SetApproximateSpacingMmPerPixel(double value) { m_ApproximateSpacingMmPerPixel = value; };

  void SetMaxLinePairDistanceErrorPercent(double value) { m_MaxLinePairDistanceErrorPercent = value; };

  void SetMaxAngleDifferenceDegrees(double value) { m_MaxAngleDiff = value; };

  void SetMinThetaDeg(double value);

  void SetMaxThetaDeg(double value);

  void SetAngleToleranceDeg(double value);

  void SetMaxLineShiftMm(double aValue);

  double GetMaxLineShiftMm();

  void SetAngleToleranceDegrees(double angleToleranceDegrees);

  void SetInclinedLineAngleDegrees(double inclinedLineAngleDegrees);

protected:
  std::array<unsigned int, 3> m_FrameSize;

  double m_ApproximateSpacingMmPerPixel;
  double m_MaxAngleDiff; // not used
  double m_MinLinePairDistMm;   // minimum distance between any two lines
  double m_MaxLinePairDistMm;  // maximum distance between any two lines
  double m_MinLinePairAngleRad; // minimum angle between any two lines
  double m_MaxLinePairAngleRad; // maximum angle between any two lines
  double m_MaxLineShiftMm; // maximum in-plane shift of the midpoint of the N fiducials
  double m_MaxLinePairDistanceErrorPercent;
  double m_MinThetaRad;
  double m_MaxThetaRad;

  bool m_DotsFound;

  double m_AngleToleranceRad;
  double m_InclinedLineAngleRad;
  double m_PatternIntensity;

  std::vector<PlusFidDot> m_DotsVector;
  std::vector<PlusFidLine> m_FoundLines;
  std::vector<PlusFidPattern*> m_Patterns;
  std::vector<PlusLabelingResults> m_Results;
  std::vector< std::vector<PlusFidLine> > m_LinesVector;
  std::vector< std::vector<double> > m_FoundDotsCoordinateValue;
};

#endif // _FIDUCIAL_LABELLING_H