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