vtkSlicerTerminologiesModuleLogic.h

Go to the documentation of this file.

/*==============================================================================
 
  Program: 3D Slicer
 
  Copyright (c) Laboratory for Percutaneous Surgery (PerkLab)
  Queen's University, Kingston, ON, Canada. All Rights Reserved.
 
  See COPYRIGHT.txt
  or http://www.slicer.org/copyright/copyright.txt for details.
 
  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
 
  This file was originally developed by Csaba Pinter, PerkLab, Queen's University
  and was supported through the Applied Cancer Research Unit program of Cancer Care
  Ontario with funds provided by the Ontario Ministry of Health and Long-Term Care
 
==============================================================================*/
 
#ifndef __vtkSlicerTerminologiesModuleLogic_h
#define __vtkSlicerTerminologiesModuleLogic_h
 
// Slicer includes
#include "vtkSlicerModuleLogic.h"
 
#include "vtkSlicerTerminologiesModuleLogicExport.h"
 
class vtkCodedEntry;
class vtkMRMLColorNode;
class vtkSegment;
class vtkStringArray;
class vtkSlicerTerminologyEntry;
class vtkSlicerTerminologyCategory;
class vtkSlicerTerminologyType;
 
class VTK_SLICER_TERMINOLOGIES_LOGIC_EXPORT vtkSlicerTerminologiesModuleLogic : public vtkSlicerModuleLogic
{
public:
  static vtkSlicerTerminologiesModuleLogic* New();
  vtkTypeMacro(vtkSlicerTerminologiesModuleLogic, vtkSlicerModuleLogic);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  class CodeIdentifier
  {
  public:
    CodeIdentifier() {};
    CodeIdentifier(std::string codingSchemeDesignator, std::string codeValue, std::string codeMeaning = std::string())
      : CodingSchemeDesignator(codingSchemeDesignator)
      , CodeValue(codeValue)
      , CodeMeaning(codeMeaning) {};
    bool IsValid() const { return !CodingSchemeDesignator.empty() && !CodeValue.empty(); };
    std::string CodingSchemeDesignator;
    std::string CodeValue;
    std::string CodeMeaning; // Human readable name (not required for ID)
  };

  static const char* GetNameAutoGeneratedAttributeName() { return "Terminologies.AutoUpdateNodeName"; };
  static const char* GetColorAutoGeneratedAttributeName() { return "Terminologies.AutoUpdateNodeColor"; };
  static const char* GetTerminologyEntryAttributeName() { return "Terminologies.TerminologyEntry"; };
  static const char* GetDefaultTerminologyEntryAttributeName() { return "Terminologies.DefaultTerminologyEntry"; };
 
  static bool GetTerminologyEntry(vtkMRMLNode* node, vtkSlicerTerminologyEntry* entry);
  static void SetTerminologyEntry(vtkMRMLNode* node, vtkSlicerTerminologyEntry* entry);
  static std::string GetTerminologyEntryAsString(vtkMRMLNode* node);
  static void SetTerminologyEntryAsString(vtkMRMLNode* node, std::string entryStr);
 
  static bool GetDefaultTerminologyEntry(vtkMRMLNode* node, vtkSlicerTerminologyEntry* entry);
  static void SetDefaultTerminologyEntry(vtkMRMLNode* node, vtkSlicerTerminologyEntry* entry);
  static std::string GetDefaultTerminologyEntryAsString(vtkMRMLNode* node);
  static void SetDefaultTerminologyEntryAsString(vtkMRMLNode* node, std::string entryStr);

  bool LoadContextFromFile(std::string filePath);
  std::string LoadTerminologyFromFile(std::string filePath);
  std::string LoadRegionContextFromFile(std::string filePath);
  bool LoadTerminologyFromSegmentDescriptorFile(std::string contextName, std::string filePath);
  bool LoadRegionContextFromSegmentDescriptorFile(std::string contextName, std::string filePath);

  void GetLoadedTerminologyNames(std::vector<std::string>& terminologyNames);
  bool IsTerminologyContextLoaded(std::string terminologyName);
  void GetLoadedTerminologyNames(vtkStringArray* terminologyNames);
  void GetLoadedRegionContextNames(std::vector<std::string>& regionContextNames);
  void GetLoadedRegionContextNames(vtkStringArray* regionContextNames);

  std::vector<std::string> GetCompatibleColorNodeIDs();

  vtkMRMLColorNode* GetFirstCompatibleColorNodeByName(std::string name);

  bool GetCategoriesInTerminology(std::string terminologyName, std::vector<CodeIdentifier>& categories);
  bool FindCategoriesInTerminology(std::string terminologyName, std::vector<CodeIdentifier>& categories, std::string search);

  std::vector<std::string> FindColorNodes(std::string categoryCodingSchemeDesignator,
                                          std::string categoryCodeValue,
                                          std::string typeCodingSchemeDesignator,
                                          std::string typeCodeValue,
                                          std::string typeModifierCodingSchemeDesignator,
                                          std::string typeModifierCodeValue,
                                          std::string regionCodingSchemeDesignator,
                                          std::string regionCodeValue,
                                          std::string regionModifierCodingSchemeDesignator,
                                          std::string regionModifierCodeValue,
                                          std::vector<std::string> preferredColorNodeNames,
                                          vtkIntArray* foundColorIndices = nullptr,
                                          vtkIntArray* foundPreferredColorNodeIndices = nullptr);

  std::vector<std::string> FindTerminologyNames(std::string categoryCodingSchemeDesignator,
                                                std::string categoryCodeValue,
                                                std::string typeCodingSchemeDesignator,
                                                std::string typeCodeValue,
                                                std::string typeModifierCodingSchemeDesignator,
                                                std::string typeModifierCodeValue,
                                                std::vector<std::string> preferredTerminologyNames,
                                                vtkCollection* foundEntries = nullptr,
                                                vtkIntArray* foundPreferredTerminologyNameIndices = nullptr);

  bool FindFirstColorNodeOrTerminology(vtkSlicerTerminologyEntry* entry,
                                       std::vector<std::string> preferredTerminologyNames,
                                       std::string& foundTerminologyName,
                                       std::string& foundColorNodeID,
                                       int& foundColorIndex);

  bool FindFirstColorNodeOrTerminology(std::string categoryCodingSchemeDesignator,
                                       std::string categoryCodeValue,
                                       std::string typeCodingSchemeDesignator,
                                       std::string typeCodeValue,
                                       std::string typeModifierCodingSchemeDesignator,
                                       std::string typeModifierCodeValue,
                                       std::string regionCodingSchemeDesignator,
                                       std::string regionCodeValue,
                                       std::string regionModifierCodingSchemeDesignator,
                                       std::string regionModifierCodeValue,
                                       std::vector<std::string> preferredTerminologyNames,
                                       std::string& foundTerminologyName,
                                       std::string& foundColorNodeID,
                                       int& foundColorIndex);

  std::vector<std::string> FindRegionContextNames(std::string regionCodingSchemeDesignator,
                                                  std::string regionCodeValue,
                                                  std::string regionModifierCodingSchemeDesignator,
                                                  std::string regionModifierCodeValue,
                                                  std::vector<std::string> preferredRegionContextNames,
                                                  vtkCollection* foundEntries = nullptr);

  bool GetCategoryInTerminology(std::string terminologyName, CodeIdentifier categoryId, vtkSlicerTerminologyCategory* categoryObject);
  int GetNumberOfCategoriesInTerminology(std::string terminologyName);
  bool GetNthCategoryInTerminology(std::string terminologyName, int categoryIndex, vtkSlicerTerminologyCategory* category);

  bool GetTypesInTerminologyCategory(std::string terminologyName, CodeIdentifier categoryId, std::vector<CodeIdentifier>& types);
  bool FindTypesInTerminologyCategory(std::string terminologyName,
                                      CodeIdentifier categoryId,
                                      std::vector<CodeIdentifier>& types,
                                      std::string search,
                                      std::vector<vtkSmartPointer<vtkSlicerTerminologyType>>* typeObjects = nullptr);
  bool GetTypeInTerminologyCategory(std::string terminologyName, CodeIdentifier categoryId, CodeIdentifier typeId, vtkSlicerTerminologyType* typeObject);
  int GetNumberOfTypesInTerminologyCategory(std::string terminologyName, vtkSlicerTerminologyCategory* category);
  bool GetNthTypeInTerminologyCategory(std::string terminologyName, vtkSlicerTerminologyCategory* category, int typeIndex, vtkSlicerTerminologyType* type);

  bool GetTypeModifiersInTerminologyType(std::string terminologyName, CodeIdentifier categoryId, CodeIdentifier typeId, std::vector<CodeIdentifier>& typeModifiers);
  bool GetTypeModifierInTerminologyType(std::string terminologyName,
                                        CodeIdentifier categoryId,
                                        CodeIdentifier typeId,
                                        CodeIdentifier modifierId,
                                        vtkSlicerTerminologyType* typeModifier);
  int GetNumberOfTypeModifiersInTerminologyType(std::string terminologyName, vtkSlicerTerminologyCategory* category, vtkSlicerTerminologyType* type);
  bool GetNthTypeModifierInTerminologyType(std::string terminologyName,
                                           vtkSlicerTerminologyCategory* category,
                                           vtkSlicerTerminologyType* type,
                                           int typeModifierIndex,
                                           vtkSlicerTerminologyType* typeModifier);

  bool GetRegionsInRegionContext(std::string regionContextName, std::vector<CodeIdentifier>& regions);
  int GetNumberOfRegionsInRegionContext(std::string regionContextName);
  bool GetNthRegionInRegionContext(std::string regionContextName, int regionIndex, vtkSlicerTerminologyType* regionObject);

  bool FindRegionsInRegionContext(std::string regionContextName, std::vector<CodeIdentifier>& regions, std::string search);
  bool GetRegionInRegionContext(std::string regionContextName, CodeIdentifier regionId, vtkSlicerTerminologyType* regionObject);

  bool GetRegionModifiersInRegion(std::string regionContextName, CodeIdentifier regionId, std::vector<CodeIdentifier>& regionModifiers);
  bool GetRegionModifierInRegion(std::string regionContextName, CodeIdentifier regionId, CodeIdentifier modifierId, vtkSlicerTerminologyType* regionModifier);
  int GetNumberOfRegionModifierInRegion(std::string regionContextName, vtkSlicerTerminologyType* regionObject);
  bool GetNthRegionModifierInRegion(std::string regionContextName, vtkSlicerTerminologyType* regionObject, int regionModifierIndex, vtkSlicerTerminologyType* regionModifier);

  bool FindTypeInTerminologyBy3dSlicerLabel(std::string terminologyName, std::string slicerLabel, vtkSlicerTerminologyEntry* entry);

  static CodeIdentifier GetCodeIdentifierFromCodedEntry(vtkCodedEntry* entry);

  static std::string SerializeTerminologyEntry(vtkSlicerTerminologyEntry* entry);

  static std::string SerializeTerminologyEntry(std::string terminologyContextName,
                                               std::string categoryValue,
                                               std::string categorySchemeDesignator,
                                               std::string categoryMeaning,
                                               std::string typeValue,
                                               std::string typeSchemeDesignator,
                                               std::string typeMeaning,
                                               std::string modifierValue,
                                               std::string modifierSchemeDesignator,
                                               std::string modifierMeaning,
                                               std::string regionContextName,
                                               std::string regionValue,
                                               std::string regionSchemeDesignator,
                                               std::string regionMeaning,
                                               std::string regionModifierValue,
                                               std::string regionModifierSchemeDesignator,
                                               std::string regionModifierMeaning);

  static bool DeserializeTerminologyEntry(std::string serializedEntry, vtkSlicerTerminologyEntry* entry);

  bool UpdateEntryFromLoadedTerminologies(vtkSlicerTerminologyEntry* entry,
                                          std::vector<std::string> preferredTerminologyNames,
                                          std::vector<std::string> preferredRegionContextNames);

  static std::string GetInfoStringFromTerminologyEntry(vtkSlicerTerminologyEntry* entry);

  // These functions are not static because in the future conversion may involve translation tables
  // to accept equivalent codes as equal (to allow comparing terms between different coding schemes)
  bool AreSegmentTerminologyEntriesEqual(vtkSegment* segment1, vtkSegment* segment2);
  bool AreTerminologyEntriesEqual(vtkSlicerTerminologyEntry* entry1, vtkSlicerTerminologyEntry* entry2);
  bool AreTerminologyEntriesEqual(std::string terminologyEntry1, std::string terminologyEntry2);
  bool AreCodedEntriesEqual(vtkCodedEntry* codedEntry1, vtkCodedEntry* codedEntry2);
  static bool AreCodedEntriesExactMatch(vtkCodedEntry* codedEntry1, vtkCodedEntry* codedEntry2);

  static int GetColorIndexByTerminology(vtkMRMLColorNode* colorNode, const std::string& terminologyStr, bool ignoreContextName = true);

  std::string LoadAnatomicContextFromFile(std::string filePath);
  // Deprecated. Use LoadRegionContextFromSegmentDescriptorFile instead.
  bool LoadAnatomicContextFromSegmentDescriptorFile(std::string contextName, std::string filePath);
  // Deprecated. Use GetLoadedRegionContextNames instead.
  void GetLoadedAnatomicContextNames(std::vector<std::string>& anatomicContextNames);
  void GetLoadedAnatomicContextNames(vtkStringArray* anatomicContextNames);
  std::vector<std::string> FindAnatomicContextNames(std::string anatomicRegionCodingSchemeDesignator,
                                                    std::string anatomicRegionCodeValue,
                                                    std::string anatomicRegionModifierCodingSchemeDesignator,
                                                    std::string anatomicRegionModifierCodeValue,
                                                    std::vector<std::string> preferredAnatomicContextNames,
                                                    vtkCollection* foundEntries = nullptr);
  bool GetRegionsInAnatomicContext(std::string anatomicContextName, std::vector<CodeIdentifier>& regions);
  int GetNumberOfRegionsInAnatomicContext(std::string anatomicContextName);
  bool GetNthRegionInAnatomicContext(std::string anatomicContextName, int regionIndex, vtkSlicerTerminologyType* regionObject);
  bool FindRegionsInAnatomicContext(std::string anatomicContextName, std::vector<CodeIdentifier>& regions, std::string search);
  bool GetRegionInAnatomicContext(std::string anatomicContextName, CodeIdentifier regionId, vtkSlicerTerminologyType* regionObject);
  bool GetRegionModifiersInAnatomicRegion(std::string anatomicContextName, CodeIdentifier regionId, std::vector<CodeIdentifier>& regionModifiers);
  bool GetRegionModifierInAnatomicRegion(std::string regionContextName, CodeIdentifier regionId, CodeIdentifier modifierId, vtkSlicerTerminologyType* regionModifier);
  int GetNumberOfRegionModifierInAnatomicRegion(std::string anatomicContextName, vtkSlicerTerminologyType* regionObject);
  bool GetNthRegionModifierInAnatomicRegion(std::string anatomicContextName,
                                            vtkSlicerTerminologyType* regionObject,
                                            int regionModifierIndex,
                                            vtkSlicerTerminologyType* regionModifier);
  static CodeIdentifier CodeIdentifierFromTerminologyCategory(vtkSlicerTerminologyCategory* category);
  static CodeIdentifier CodeIdentifierFromTerminologyType(vtkSlicerTerminologyType* type);
 
public:
  vtkGetStringMacro(UserContextsPath);
  vtkSetStringMacro(UserContextsPath);
 
protected:
  vtkSlicerTerminologiesModuleLogic();
  ~vtkSlicerTerminologiesModuleLogic() override;
 
  void SetMRMLSceneInternal(vtkMRMLScene* newScene) override;

  void LoadDefaultTerminologies();
  void LoadDefaultRegionContexts();
  void LoadUserContexts();
 
protected:
  char* UserContextsPath{ nullptr };
 
private:
  vtkSlicerTerminologiesModuleLogic(const vtkSlicerTerminologiesModuleLogic&) = delete;
  void operator=(const vtkSlicerTerminologiesModuleLogic&) = delete;
 
  class vtkInternal;
  vtkInternal* Internal;
  friend class vtkInternal;
};
 
#endif