vtkMRMLColorNode.h

Go to the documentation of this file.

/*=auto=========================================================================
 
  Portions (c) Copyright 2006 Brigham and Women's Hospital (BWH) All Rights Reserved.
 
  See COPYRIGHT.txt
  or http://www.slicer.org/copyright/copyright.txt for details.
 
  Program:   3D Slicer
  Module:    $RCSfile: vtkMRMLColorNode.h,v $
  Date:      $Date: 2006/03/19 17:12:28 $
  Version:   $Revision: 1.0 $
 
=========================================================================auto=*/
 
#ifndef __vtkMRMLColorNode_h
#define __vtkMRMLColorNode_h
 
// MRML includes
#include "vtkMRMLStorableNode.h"
#include "vtkCodedEntry.h"
 
// VTK includes
class vtkCodedEntry;
class vtkLookupTable;
class vtkScalarsToColors;
 
// Std includes
#include <string>
#include <vector>

class VTK_MRML_EXPORT vtkMRMLColorNode : public vtkMRMLStorableNode
{
public:
  vtkTypeMacro(vtkMRMLColorNode,vtkMRMLStorableNode);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  vtkMRMLNode* CreateNodeInstance() override = 0;
 
  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------

  void ReadXMLAttributes( const char** atts) override;

  void WriteXML(ostream& of, int indent) override;

  vtkMRMLCopyContentMacro(vtkMRMLColorNode);

  const char* GetNodeTagName() override {return "Color";};

  void Reset(vtkMRMLNode* defaultNode) override;

  void UpdateScene(vtkMRMLScene *scene) override;

  virtual void SetType(int type);
  vtkGetMacro(Type,int);

  void SetTypeToUser();
  void SetTypeToFile();
 
  void ProcessMRMLEvents ( vtkObject *caller, unsigned long event, void *callData ) override;

  virtual int GetFirstType () { return this->User; }
  virtual int GetLastType () { return this->File; }

  virtual const char* GetTypeAsString();

  enum
  {
    TypeModifiedEvent = 20002
  };

  bool GetColorDefined(int ind);

  void SetColorDefined(int ind, bool defined);

  const char* GetColorName(int ind);

  int GetColorIndexByName(const char* name);

  std::string GetColorNameAsFileName(int colorIndex, const char *subst = "_");

  std::string GetColorNameWithoutSpaces(int ind, const char *subst);

  int SetColorName(int ind, const char* name);

  int SetColorNameWithSpaces(int ind, const char *name, const char *subst);
 
  // @{
  vtkCodedEntry* GetTerminologyCategory(int ind);
  vtkCodedEntry* GetTerminologyType(int ind);
  vtkCodedEntry* GetTerminologyTypeModifier(int ind);
  vtkCodedEntry* GetTerminologyRegion(int ind);
  vtkCodedEntry* GetTerminologyRegionModifier(int ind);
  std::string GetTerminologyAsString(int ind);
  // @}

  bool SetTerminologyFromString(int ind, std::string terminologyString);

  bool SetTerminology(int ind,
    std::string categoryCodingScheme, std::string categoryCodeValue, std::string categoryCodeMeaning,
    std::string typeCodingScheme, std::string typeCodeValue, std::string typeCodeMeaning,
    std::string typeModifierCodingScheme="", std::string typeModifierCodeValue="", std::string typeModifierCodeMeaning="",
    std::string regionCodingScheme="", std::string regionCodeValue="", std::string regionCodeMeaning="",
    std::string regionModifierCodingScheme="", std::string regionModifierCodeValue="", std::string regionModifierCodeMeaning="");

  static std::string GetTerminologyAsString(std::string terminologyContextName,
    vtkCodedEntry* category, vtkCodedEntry* type, vtkCodedEntry* typeModifier,
    std::string regionContextName="", vtkCodedEntry* region=nullptr, vtkCodedEntry* regionModifier=nullptr);

  const char* GetContainsTerminologyAttributeName() { return "ContainsTerminology"; };
  bool GetContainsTerminology();

  virtual int GetNumberOfColors() = 0;

  virtual bool GetColor(int ind, double color[4]) = 0;

  virtual vtkLookupTable* GetLookupTable();

  virtual vtkScalarsToColors* GetScalarsToColors();

  const char* GetNoName()
  {
    vtkWarningMacro("GetNoName() method is deprecated use GetColorDefined() and SetColorDefined() methods instead");
    return "(none)";
  }
  const char* GetNoName() {…}

  void SetNoName(const char*)
  {
    vtkErrorMacro("SetNoName() method is deprecated use GetColorDefined() and SetColorDefined() methods instead");
  }
  void SetNoName(const char*) {…}
 
  // @{
  void NamesInitialisedOn()
  {
    vtkErrorMacro("NamesInitialisedOn() method is deprecated and has no effect and no longer necessary.");
  }
  void NamesInitialisedOn() {…}
  void NamesInitialisedOff()
  {
    vtkErrorMacro("NamesInitialisedOff() method is deprecated and has no effect and no longer necessary.");
  }
  void NamesInitialisedOff() {…}
  void SetNamesInitialised(int)
  {
    vtkErrorMacro("SetNamesInitialised() method is deprecated and has no effect. Use SetColorName() and SetColorDefined() methods instead.");
  }
  void SetNamesInitialised(int) {…}
  int GetNamesInitialised(int)
  {
    vtkErrorMacro("GetNamesInitialised() method is deprecated. Use SetColorName() and SetColorDefined() methods to set and unset color names.");
    return 1;
  }
  int GetNamesInitialised(int) {…}
  // @}

  void SetNamesFromColors();

  bool GetModifiedSinceRead() override;

  enum
  {
    User = 13,
    File = 14,
  };

  virtual vtkLookupTable* CreateLookupTableCopy();
 
protected:
  vtkMRMLColorNode();
  ~vtkMRMLColorNode() override;
  vtkMRMLColorNode(const vtkMRMLColorNode&);
  void operator=(const vtkMRMLColorNode&);

  void SetContainsTerminology(bool containsTerminology);
 
  struct PropertyType
  {
    // The label value and corresponding color has been explicitly set.
    // If the label value is not included in the color table file then "Defined" will set to false.
    bool Defined{ false };
    std::string Name;
    vtkSmartPointer<vtkCodedEntry> Category;
    vtkSmartPointer<vtkCodedEntry> Type;
    vtkSmartPointer<vtkCodedEntry> TypeModifier;
    vtkSmartPointer<vtkCodedEntry> Region;
    vtkSmartPointer<vtkCodedEntry> RegionModifier;
    void DeepCopy(PropertyType& source)
    {
      this->Defined = source.Defined;
      this->Name = source.Name;
      this->Category = source.Category;
      this->Type = source.Type;
      this->TypeModifier = source.TypeModifier;
      this->Region = source.Region;
      this->RegionModifier = source.RegionModifier;
    }
    void DeepCopy(PropertyType& source) {…}
    void Clear()
    {
      this->Defined = false;
      this->Name.clear();
      this->Category = nullptr;
      this->Type = nullptr;
      this->TypeModifier = nullptr;
      this->Region = nullptr;
      this->RegionModifier = nullptr;
    }
    void Clear() {…}
    bool operator==(const PropertyType& other) const
    {
      return this->Defined == other.Defined &&
        this->Name == other.Name &&
        vtkCodedEntry::AreEqual(this->Category, other.Category) &&
        vtkCodedEntry::AreEqual(this->Type, other.Type) &&
        vtkCodedEntry::AreEqual(this->TypeModifier, other.TypeModifier) &&
        vtkCodedEntry::AreEqual(this->Region, other.Region) &&
        vtkCodedEntry::AreEqual(this->RegionModifier, other.RegionModifier);
    }
    bool operator==(const PropertyType& other) const {…}
    bool operator!=(const PropertyType& other) const
    {
      return !(*this == other);
    }
    bool operator!=(const PropertyType& other) const {…}
  };
  struct PropertyType {…};
 
  bool GetProperty(int ind, PropertyType& prop);

  virtual bool SetNameFromColor(int index);

  int Type;

  std::vector<PropertyType> Properties;
};
class VTK_MRML_EXPORT vtkMRMLColorNode : public vtkMRMLStorableNode {…};
 
#endif