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

  class CodeIdentifier
    {
    public:
      CodeIdentifier()
        : CodingSchemeDesignator("")
        , CodeValue("")
        , CodeMeaning("")
        { };
      CodeIdentifier(std::string codingSchemeDesignator, std::string codeValue, std::string codeMeaning)
        : CodingSchemeDesignator(codingSchemeDesignator)
        , CodeValue(codeValue)
        , CodeMeaning(codeMeaning)
        { };
      std::string CodingSchemeDesignator;
      std::string CodeValue;
      std::string CodeMeaning; // Human readable name (not required for ID)
    };

  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);
  bool GetCategoryInTerminology(std::string terminologyName, CodeIdentifier categoryId, vtkSlicerTerminologyCategory* categoryObject);

  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);
  bool GetTypeInTerminologyCategory(std::string terminologyName, CodeIdentifier categoryId, CodeIdentifier typeId, vtkSlicerTerminologyType* typeObject);

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

  bool GetRegionsInAnatomicContext(std::string anatomicContextName, std::vector<CodeIdentifier>& regions);
  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);

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

  static CodeIdentifier CodeIdentifierFromTerminologyCategory(vtkSlicerTerminologyCategory* category);
  static CodeIdentifier CodeIdentifierFromTerminologyType(vtkSlicerTerminologyType* type);

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

public:
  vtkGetStringMacro(UserContextsPath);
  vtkSetStringMacro(UserContextsPath);

protected:
  vtkSlicerTerminologiesModuleLogic();
  virtual ~vtkSlicerTerminologiesModuleLogic();

  virtual void SetMRMLSceneInternal(vtkMRMLScene* newScene) VTK_OVERRIDE;

  void LoadDefaultTerminologies();
  void LoadDefaultAnatomicContexts();
  void LoadUserContexts();

protected:
  char* UserContextsPath;

private:
  vtkSlicerTerminologiesModuleLogic(const vtkSlicerTerminologiesModuleLogic&); // Not implemented
  void operator=(const vtkSlicerTerminologiesModuleLogic&);              // Not implemented

  class vtkInternal;
  vtkInternal* Internal;
  friend class vtkInternal;
};

#endif