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