PlusFidPatternRecognitionCommon.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_ALGORITHM_COMMON_H
#define _FIDUCIAL_ALGORITHM_COMMON_H

#include "vtkPlusCalibrationExport.h"

#include <vector>
#include <string>

class vtkPlusCalibrationExport PlusFidDot
{
public:
  static bool IntensityLessThan(const PlusFidDot& dot1, const PlusFidDot& dot2);

  static bool PositionLessThan(std::vector<PlusFidDot>::iterator b1, std::vector<PlusFidDot>::iterator b2);

  void SetX(double value);

  double GetX() const;

  void  SetY(double value);

  double GetY() const;

  void SetDotIntensity(double value);

  double GetDotIntensity() const;

  double GetDistanceFrom(PlusFidDot& d);

  bool operator== (const PlusFidDot& data) const;

protected:
  double  m_X;
  double  m_Y;
  double  m_DotIntensity;
};

//-----------------------------------------------------------------------------
class vtkPlusCalibrationExport PlusFidLine
{
public:
  static bool lessThan(const PlusFidLine& line1, const PlusFidLine& line2);

  static bool compareLines(const PlusFidLine& line1, const PlusFidLine& line2);

  static double ComputeAngleRad(const PlusFidLine& line1);

  static double ComputeAngleRad(const PlusFidLine& line1, const PlusFidLine& line2);

  void SetPoint(int aIndex, int aValue);

  int  GetPoint(int aIndex) const;

  unsigned int GetNumberOfPoints() const;

  void SetIntensity(double value);

  double GetIntensity() const;

  void SetLength(double value);

  double GetLength() const { return Length; };

  void SetDirectionVector(int aIndex, double aValue);

  const double* GetDirectionVector() const;

  void  SetStartPointIndex(int index);

  int GetStartPointIndex() const;

  void SetEndPointIndex(int index);

  int GetEndPointIndex() const;

  void ResizePoints(int aNewSize);

  void AddPoint(int aPoint);

protected:
  std::vector<int>  Points;
  double            Intensity;
  double            Length;
  double            DirectionVector[2];
  int               StartPointIndex;
  int               EndPointIndex;
};

//-----------------------------------------------------------------------------
class vtkPlusCalibrationExport PlusFidWire
{
public:
  void SetName(const std::string& aName);
  std::string GetName() const;

  double EndPointFront[3];
  double EndPointBack[3];

protected:
  std::string Name;
};

//-----------------------------------------------------------------------------
class vtkPlusCalibrationExport PlusFidPattern
{
public:
  virtual ~PlusFidPattern();

  const std::vector<PlusFidWire>& GetWires() const;
  const std::vector<double>& GetDistanceToOriginMm() const;
  const std::vector<double>& GetDistanceToOriginToleranceMm() const;

  void AddWire(const PlusFidWire& wire);
  void AddDistanceToOriginElementMm(double aElement);
  void SetDistanceToOriginElementMm(int index, double aElement);
  void AddDistanceToOriginToleranceElementMm(double aElement);
  void SetDistanceToOriginToleranceElementMm(int index, double aElement);

protected:
  std::vector<PlusFidWire> Wires;
  std::vector<double>  DistanceToOriginMm;
  std::vector<double>  DistanceToOriginToleranceMm;
};

//-----------------------------------------------------------------------------
class vtkPlusCalibrationExport PlusNWire : public PlusFidPattern
{
public:
  virtual ~PlusNWire();

  double IntersectPosW12[3];
  double IntersectPosW32[3];
};

//-----------------------------------------------------------------------------
class vtkPlusCalibrationExport PlusCoplanarParallelWires : public PlusFidPattern
{
public:
  virtual ~PlusCoplanarParallelWires();
};

//-----------------------------------------------------------------------------
class vtkPlusCalibrationExport PlusPatternRecognitionResult
{
public:
  PlusPatternRecognitionResult();

  void Clear();

  void SetDotsFound(bool value);

  bool GetDotsFound();

  void SetFoundDotsCoordinateValue(std::vector< std::vector<double> > value);

  std::vector< std::vector<double> >&  GetFoundDotsCoordinateValue();

  void SetIntensity(double value) { Intensity = value; };

  double GetIntensity() const { return Intensity; };

  void SetNumDots(double value) { NumDots = value; };

  double GetNumDots() const { return NumDots; };

  void SetCandidateFidValues(std::vector<PlusFidDot> value);

  const std::vector<PlusFidDot>& GetCandidateFidValues() const;

protected:
  std::vector< std::vector<double> >  FoundDotsCoordinateValue;

  std::vector<PlusFidDot>  CandidateFidValues;

  bool DotsFound;

  double Intensity;

  double NumDots;
};

#endif //_FIDUCIAL_ALGORITHM_COMMON_H