vtkMRMLMeasurement.h

Go to the documentation of this file.

/*=auto=========================================================================

Portions (c) Copyright 2017 Brigham and Women's Hospital (BWH) All Rights Reserved.

See COPYRIGHT.txt
or http://www.slicer.org/copyright/copyright.txt for details.

=========================================================================auto=*/

#ifndef __vtkMRMLMeasurement_h
#define __vtkMRMLMeasurement_h

//#define USE_POLYDATA_MEASUREMENTS

// MRML includes
#include <vtkCodedEntry.h>
#include "vtkMRMLNode.h"

// VTK includes
#include <vtkCommand.h>
#include <vtkDoubleArray.h>
#include <vtkObject.h>
#include <vtkPolyData.h>
#include <vtkSmartPointer.h>

class vtkMRMLUnitNode;

class VTK_MRML_EXPORT vtkMRMLMeasurement : public vtkObject
{
public:
  enum ComputationResult
    {
    NoChange=0, 
    OK, 
    InsufficientInput,
    InternalError
    };

  enum Events
  {
    // vtkCommand::UserEvent + 555 is just a random value that is very unlikely to be used for anything else in this class
    InputDataModifiedEvent = vtkCommand::UserEvent + 555
  };

  vtkTypeMacro(vtkMRMLMeasurement, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  VTK_NEWINSTANCE
  virtual vtkMRMLMeasurement* CreateInstance() const = 0;

  virtual void Clear();

  virtual void ClearValue(ComputationResult computationResult=NoChange);

  virtual void Copy(vtkMRMLMeasurement* source);

  virtual void Compute() = 0;

  vtkGetMacro(Enabled, bool);
  virtual void SetEnabled(bool enabled);
  virtual void EnabledOn();
  virtual void EnabledOff();

  vtkGetMacro(Name, std::string);
  vtkSetMacro(Name, std::string);

  void SetValue(double value, const char* quantityName = nullptr);

  vtkGetMacro(Value, double);

  void SetDisplayValue(double value, const char* units=nullptr, double displayCoefficient=0.0);

  double GetDisplayValue();

  vtkGetMacro(ValueDefined, bool);

  vtkGetMacro(Units, std::string);
  virtual void SetUnits(std::string units);

  vtkGetMacro(DisplayCoefficient, double);
  vtkSetMacro(DisplayCoefficient, double);

  vtkGetMacro(Description, std::string);
  vtkSetMacro(Description, std::string);

  vtkGetMacro(PrintFormat, std::string);
  virtual void SetPrintFormat(std::string format);

  void SetQuantityCode(vtkCodedEntry* entry);
  virtual vtkCodedEntry* GetQuantityCode();

  void SetDerivationCode(vtkCodedEntry* entry);
  virtual vtkCodedEntry* GetDerivationCode();

  void SetUnitsCode(vtkCodedEntry* entry);
  virtual vtkCodedEntry* GetUnitsCode();

  void SetMethodCode(vtkCodedEntry* entry);
  virtual vtkCodedEntry* GetMethodCode();

  vtkGetMacro(LastComputationResult, int);
  const char* GetLastComputationResultAsPrintableString();

  std::string GetValueWithUnitsAsPrintableString();

  void SetControlPointValues(vtkDoubleArray* inputValues);
  vtkGetObjectMacro(ControlPointValues, vtkDoubleArray);

  void SetMeshValue(vtkPolyData* meshValue);
  virtual vtkPolyData* GetMeshValue();

  void SetInputMRMLNode(vtkMRMLNode* node);
  vtkMRMLNode* GetInputMRMLNode();

protected:
  vtkMRMLMeasurement();
  ~vtkMRMLMeasurement() override;
  vtkMRMLMeasurement(const vtkMRMLMeasurement&);
  void operator=(const vtkMRMLMeasurement&);

  vtkMRMLUnitNode* GetUnitNode(const char* quantityName);

protected:
  bool Enabled{true};
  std::string Name;
  double Value{0.0};
  bool ValueDefined{false};
  double DisplayCoefficient{1.0};  std::string Units;
  std::string Description;
  std::string PrintFormat; // for value (double), unit (string)
  vtkSmartPointer<vtkCodedEntry> QuantityCode;   // volume
  vtkSmartPointer<vtkCodedEntry> DerivationCode; // min/max/mean
  vtkSmartPointer<vtkCodedEntry> UnitsCode;      // cubic millimeter
  vtkSmartPointer<vtkCodedEntry> MethodCode;     // Sum of segmented voxel volumes
  ComputationResult LastComputationResult{InsufficientInput};

  vtkSmartPointer<vtkDoubleArray> ControlPointValues;
  vtkSmartPointer<vtkPolyData> MeshValue;
  vtkWeakPointer<vtkMRMLNode> InputMRMLNode;
};

#endif