vtkPlusUsImagingParameters.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 __vtkPlusUsImagingParameters_h
#define __vtkPlusUsImagingParameters_h

#include "vtkPlusDataCollectionExport.h"

#include <string>
#include <map>

class vtkPlusDataCollectionExport vtkPlusUsImagingParameters : public vtkObject
{
protected:
  class ParameterInfo
  {
  public:
    ParameterInfo() : Value(""), Set(false), Pending(false) {};
    ParameterInfo(std::string defaultValue) : Value(defaultValue), Set(false), Pending(false) {};

    std::string Value;
    bool Set;
    bool Pending;
  };
  typedef std::map<std::string, ParameterInfo> ParameterMap;
  typedef ParameterMap::iterator ParameterMapIterator;
  typedef ParameterMap::const_iterator ParameterMapConstIterator;

  ParameterMapConstIterator begin() const;
  ParameterMapConstIterator end() const;

public:
  static const char* XML_ELEMENT_TAG;
  static const char* US_PARAMETER_TAG;
  static const char* NAME_TAG;
  static const char* VALUE_TAG;
  static const char* KEY_FREQUENCY;
  static const char* KEY_DEPTH;
  static const char* KEY_FOCUS_DEPTH;
  static const char* KEY_DYNRANGE;
  static const char* KEY_GAIN;
  static const char* KEY_TGC;
  static const char* KEY_INTENSITY;
  static const char* KEY_CONTRAST;
  static const char* KEY_POWER;
  static const char* KEY_SECTOR;
  static const char* KEY_ZOOM;
  static const char* KEY_SOUNDVELOCITY;
  static const char* KEY_VOLTAGE;
  static const char* KEY_IMAGESIZE;

public:
  static vtkPlusUsImagingParameters* New();
  vtkTypeMacro(vtkPlusUsImagingParameters, vtkObject);

  virtual PlusStatus ReadConfiguration(vtkXMLDataElement* deviceConfig);

  virtual PlusStatus WriteConfiguration(vtkXMLDataElement* deviceConfig);

  virtual PlusStatus DeepCopy(const vtkPlusUsImagingParameters& otherParameters);

  template<typename T> PlusStatus GetValue(const std::string& paramName, T& outputValue) const
  {
    ParameterMapConstIterator keyIt = this->Parameters.find(paramName);
    if (keyIt != this->Parameters.end() && keyIt->second.Set == false)
    {
      return PLUS_FAIL;
    }
    else if (keyIt == this->Parameters.end())
    {
      return PLUS_FAIL;
    }

    std::stringstream ss;
    ParameterMapConstIterator it = this->Parameters.find(paramName);
    ss.str(it->second.Value);
    ss >> outputValue;
    return PLUS_SUCCESS;
  }

  template<typename T> PlusStatus SetValue(const std::string& paramName, T aValue)
  {
    std::stringstream ss;
    ss << aValue;
    if (this->Parameters[paramName].Value != ss.str())
    {
      this->Parameters[paramName].Pending = true;
    }
    this->Parameters[paramName].Value = ss.str();
    this->Parameters[paramName].Set = true;
    return PLUS_SUCCESS;
  };
  bool IsSet(const std::string& paramName) const;
  bool IsPending(const std::string& paramName) const;
  PlusStatus SetPending(const std::string& paramName, bool pending);

  PlusStatus SetFrequencyMhz(double aFrequencyMhz);
  PlusStatus GetFrequencyMhz(double& aFrequencyMhz) const;
  double GetFrequencyMhz() const;

  PlusStatus SetDepthMm(double aDepthMm);
  PlusStatus GetDepthMm(double& aDepthMm) const;
  double GetDepthMm() const;

  PlusStatus SetFocusDepthPercent(double aFocusDepthPercent);
  PlusStatus GetFocusDepthPercent(double& aFocusDepthPercent) const;
  double GetFocusDepthPercent() const;

  PlusStatus SetGainPercent(double aGainPercent);
  PlusStatus GetGainPercent(double aGainPercent) const;
  double GetGainPercent() const;

  PlusStatus SetTimeGainCompensation(const std::vector<double>& tgc);
  PlusStatus SetTimeGainCompensation(double* tgc, int length);
  PlusStatus GetTimeGainCompensation(std::vector<double>& tgc) const;
  std::vector<double> GetTimeGainCompensation() const;

  PlusStatus SetIntensity(double aIntensity);
  PlusStatus GetIntensity(double& aIntensity) const;
  double GetIntensity() const;

  PlusStatus SetContrast(double aContrast);
  PlusStatus GetContrast(double& aContrast) const;
  double GetContrast() const;

  PlusStatus SetPowerDb(double aPower);
  PlusStatus GetPowerDb(double& aPower) const;
  double GetPowerDb() const;

  PlusStatus SetDynRangeDb(double aDynRangeDb);
  PlusStatus GetDynRangeDb(double& aDynRangeDb) const;
  double GetDynRangeDb() const;

  PlusStatus SetZoomFactor(double aZoomFactor);
  PlusStatus GetZoomFactor(double& aZoomFactor) const;
  double GetZoomFactor() const;

  PlusStatus SetSectorPercent(double aSectorPercent);
  PlusStatus GetSectorPercent(double& aSectorPercent) const;
  double GetSectorPercent() const;

  PlusStatus SetSoundVelocity(float aSoundVelocity);
  PlusStatus GetSoundVelocity(float& aSoundVelocity) const;
  float GetSoundVelocity() const;

  PlusStatus SetProbeVoltage(float aVoltage);
  PlusStatus GetProbeVoltage(float& aVoltage) const;
  float GetProbeVoltage() const;

  PlusStatus SetImageSize(const FrameSizeType& imageSize);
  PlusStatus SetImageSize(unsigned int x, unsigned int y, unsigned int z);
  PlusStatus GetImageSize(FrameSizeType& imageSize) const;
  FrameSizeType GetImageSize() const;

  virtual void PrintSelf(ostream& os, vtkIndent indent) VTK_OVERRIDE;

  enum ImagingMode
  {
    BMode                 = 0,
    MMode                 = 1,
    ColourMode            = 2,
    PwMode                = 3,
    TriplexMode           = 4,
    PanoMode              = 5,
    DualMode              = 6,
    QuadMode              = 7,
    CompoundMode          = 8,
    DualColourMode        = 9,
    DualCompoundMode      = 10,
    CwMode                = 11,
    RfMode                = 12,
    ColorSplitMode        = 13,
    F4DMode               = 14,
    TriplexCwMode         = 15,
    ColourMMode           = 16,
    ElastoMode            = 17,
    SDUVMode              = 18,
    AnatomicalMMode       = 19,
    ElastoComparativeMode = 20,
    FusionMode            = 21,
    VecDopMode            = 22,
    BiplaneMode           = 23,
    ClinicalRfMode        = 24,
    RfCompoundMode        = 25,
    SHINEMode             = 26,
    ColourRfMode          = 27
  };

  enum DataType
  {
    DataTypeScreen                = 0x00000001,
    DataTypeBPre                  = 0x00000002,
    DataTypeBPost                 = 0x00000004,
    DataTypeBPost32               = 0x00000008,
    DataTypeRF                    = 0x00000010,
    DataTypeMPre                  = 0x00000020,
    DataTypeMPost                 = 0x00000040,
    DataTypePWRF                  = 0x00000080,
    DataTypePWSpectrum            = 0x00000100,
    DataTypeColorRF               = 0x00000200,
    DataTypeColorCombined         = 0x00000400,
    DataTypeColorVelocityVariance = 0x00000800,
    DataTypeContrast              = 0x00001000,
    DataTypeElastoCombined        = 0x00002000,
    DataTypeElastoOverlay         = 0x00004000,
    DataTypeElastoPre             = 0x00008000,
    DataTypeECG                   = 0x00010000,
    DataTypeGPS1                  = 0x00020000,
    DataTypeGPS2                  = 0x00040000,
    DataTypeTimeStamp             = 0x00080000,
    DataTypeColorSpectrumRF       = 0x00100000,
    DataTypeMRF                   = 0x00200000,
    DataTypeDAQRF                 = 0x00400000,
    DataType3DPre                 = 0x00800000,
    DataType3DPost                = 0x01000000,
    DataTypePNG                   = 0x10000000
  };

protected:
  vtkPlusUsImagingParameters();
  virtual ~vtkPlusUsImagingParameters();

  ParameterMap Parameters;
};

#endif