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"
 
#include <vtkVector.h>
 
class vtkCodedEntry;
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"; };
 
  bool LoadContextFromFile(std::string filePath);
  std::string LoadTerminologyFromFile(std::string filePath);
  std::string LoadAnatomicContextFromFile(std::string filePath);
  bool LoadTerminologyFromSegmentDescriptorFile(std::string contextName, std::string filePath);
  bool LoadAnatomicContextFromSegmentDescriptorFile(std::string contextName, std::string filePath);
 
  void GetLoadedTerminologyNames(std::vector<std::string> &terminologyNames);
  void GetLoadedTerminologyNames(vtkStringArray* terminologyNames);
  void GetLoadedAnatomicContextNames(std::vector<std::string> &anatomicContextNames);
  void GetLoadedAnatomicContextNames(vtkStringArray* anatomicContextNames);
 
  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> 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);
 
  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 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 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 anatomicContextName,
    CodeIdentifier regionId, CodeIdentifier modifierId, vtkSlicerTerminologyType* regionModifier);
  int GetNumberOfRegionModifierInAnatomicRegion(std::string anatomicContextName, vtkSlicerTerminologyType* regionObject);
  bool GetNthRegionModifierInAnatomicRegion(std::string anatomicContextName, 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 anatomicContextName,
    std::string regionValue, std::string regionSchemeDesignator, std::string regionMeaning,
    std::string regionModifierValue, std::string regionModifierSchemeDesignator, std::string regionModifierMeaning );
 
  bool DeserializeTerminologyEntry(std::string serializedEntry, vtkSlicerTerminologyEntry* entry);
 
  bool UpdateEntryFromLoadedTerminologies(vtkSlicerTerminologyEntry* entry);
 
  static std::string GetInfoStringFromTerminologyEntry(vtkSlicerTerminologyEntry* entry);
 
  // These functions are not static because in the future conversion may involve translation tables.
  // (that allows comparing of 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);
 
public:
  vtkGetStringMacro(UserContextsPath);
  vtkSetStringMacro(UserContextsPath);
 
protected:
  vtkSlicerTerminologiesModuleLogic();
  ~vtkSlicerTerminologiesModuleLogic() override;
 
  void SetMRMLSceneInternal(vtkMRMLScene* newScene) override;
 
  void LoadDefaultTerminologies();
  void LoadDefaultAnatomicContexts();
  void LoadUserContexts();
 
protected:
  char* UserContextsPath{nullptr};
 
private:
  vtkSlicerTerminologiesModuleLogic(const vtkSlicerTerminologiesModuleLogic&) = delete;
  void operator=(const vtkSlicerTerminologiesModuleLogic&) = delete;
 
  class vtkInternal;
  vtkInternal* Internal;
  friend class vtkInternal;
};
 
#endif