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);

  void SetAllColorsDefined();

  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)";
  }

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

  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 Clear()
    {
      this->Defined = false;
      this->Name.clear();
      this->Category = nullptr;
      this->Type = nullptr;
      this->TypeModifier = nullptr;
      this->Region = nullptr;
      this->RegionModifier = nullptr;
    }
    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 { return !(*this == other); }
  };
 
  bool GetProperty(int ind, PropertyType& prop);

  virtual bool SetNameFromColor(int index);

  int Type;

  std::vector<PropertyType> Properties;
};
 
#endif