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 <vtkDoubleArray.h>
#include <vtkObject.h>
#include <vtkPolyData.h>
#include <vtkSmartPointer.h>

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

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

  virtual void Initialize();

  virtual void ClearValue(ComputationResult computationResult=NoChange);

  virtual void Copy(vtkMRMLMeasurement* aEntry);

  virtual void Compute() = 0;

  vtkSetMacro(Enabled, bool);
  vtkGetMacro(Enabled, bool);
  vtkBooleanMacro(Enabled, bool);

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

  vtkGetMacro(Value, double);
  void SetValue(double value);

  void SetValue(double value, const std::string& units, const std::string& printFormat, int lastComputationResult);

  vtkGetMacro(ValueDefined, bool);

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

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

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

  void SetQuantityCode(vtkCodedEntry* entry);
  vtkGetObjectMacro(QuantityCode, vtkCodedEntry);

  void SetDerivationCode(vtkCodedEntry* entry);
  vtkGetObjectMacro(DerivationCode, vtkCodedEntry);

  void SetUnitsCode(vtkCodedEntry* entry);
  vtkGetObjectMacro(UnitsCode, vtkCodedEntry);

  void SetMethodCode(vtkCodedEntry* entry);
  vtkGetObjectMacro(MethodCode, vtkCodedEntry);

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

  std::string GetValueWithUnitsAsPrintableString();

  std::string GetAsString();

  bool SetFromString(const std::string& content);

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

#ifdef USE_POLYDATA_MEASUREMENTS
  void SetPolyDataValues(vtkPolyData* inputValues);
  vtkGetObjectMacro(PolyDataValues, vtkPolyData);
#endif

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

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

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

  vtkDoubleArray* ControlPointValues{nullptr};
#ifdef USE_POLYDATA_MEASUREMENTS
  vtkPolyData* PolyDataValues{nullptr};
#endif
  vtkWeakPointer<vtkMRMLNode> InputMRMLNode;
};

#endif