mitkLabel.h

Go to the documentation of this file.

/*============================================================================
 
The Medical Imaging Interaction Toolkit (MITK)
 
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
 
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
 
============================================================================*/
 
#ifndef mitkLabel_h
#define mitkLabel_h
 
#include <MitkMultilabelExports.h>
#include <mitkColorProperty.h>
#include <mitkPropertyList.h>
#include <mitkPoint.h>
#include <mitkVector.h>
#include <mitkPropertyKeyPath.h>
#include <mitkDICOMCodeSequence.h>
#include <mitkDICOMCodeSequenceWithModifiers.h>
 
#include <optional>
#include <map>
 
namespace mitk
{
  namespace LabelPropertyConstants
  {
    MITKMULTILABEL_EXPORT const std::string& GetAnatomicRegionPropertyBaseName();
 
    MITKMULTILABEL_EXPORT const std::string& GetPrimaryAnatomicStructurePropertyBaseName();
 
    MITKMULTILABEL_EXPORT const std::string& GetSegmentedPropertyCategoryPropertyBaseName();
 
    MITKMULTILABEL_EXPORT const std::string& GetSegmentedPropertyTypePropertyBaseName();
 
    MITKMULTILABEL_EXPORT const std::string& GetModifierPropertySubName();
 
    MITKMULTILABEL_EXPORT const std::string& GetValuePropertySubName();
 
    MITKMULTILABEL_EXPORT const std::string& GetSchemePropertySubName();
 
    MITKMULTILABEL_EXPORT const std::string& GetMeaningPropertySubName();
  }
 
  class MITKMULTILABEL_EXPORT Label : public PropertyList
  {
  public:
    mitkClassMacro(Label, mitk::PropertyList);
 
    typedef unsigned short PixelType;
 
    itkNewMacro(Self);
    mitkNewMacro2Param(Self, PixelType, const std::string&);
 
    static const PixelType MAX_LABEL_VALUE;
 
    static constexpr PixelType UNLABELED_VALUE = 0;
 
    void SetLocked(bool locked);
 
    bool GetLocked() const;
 
    void SetVisible(bool visible);
 
    bool GetVisible() const;
 
    void SetOpacity(float opacity);
 
    float GetOpacity() const;
 
    void SetName(const std::string &name);
 
    std::string GetName() const;
 
    void SetTrackingID(const std::string& trackingID);
 
    std::string GetTrackingID() const;
 
    bool HasTrackingID() const;
 
    void SetTrackingUID(const std::string& trackingUID);
 
    std::string GetTrackingUID() const;
 
    bool HasTrackingUID() const;
 
    void SetDescription(const std::string& description);
 
    std::string GetDescription() const;
 
    mitk::Point3D GetCenterOfMassIndex() const;
 
    mitk::Point3D GetCenterOfMassCoordinates() const;
 
    void ResetCenterOfMass();
 
    itk::ModifiedTimeType GetCenterOfMassMTime() const;
 
    void UpdateCenterOfMass(const mitk::Point3D& index, const mitk::Point3D& coordinates);
 
    void SetColor(const mitk::Color & color);
 
    const mitk::Color &GetColor() const;
 
    void SetValue(PixelType pixelValue);
 
    PixelType GetValue() const;
 
    enum class AlgorithmType
    {
      Undefined = 0,   
      MANUAL,          
      SEMIAUTOMATIC,   
      AUTOMATIC        
    };
 
    void SetAlgorithmType(AlgorithmType algoType);
 
    void SetAlgorithmTypeStr(const std::string& algoType);
 
    AlgorithmType GetAlgorithmType() const;
 
    std::string GetAlgorithmTypeStr() const;
 
    void SetAlgorithmName(const std::string& algoName);
 
    std::string GetAlgorithmName() const;
 
    bool HasAlgorithmName() const;
 
    void AddToolUse(AlgorithmType algoType, const std::string& algoName);
 
    void MergeToolUses(const Label* other);
 
    void SetAnatomicRegion(const DICOMCodeSequenceWithModifiers& code, std::size_t index = 0);
 
    DICOMCodeSequenceWithModifiers GetAnatomicRegion(std::size_t index = 0) const;
 
    std::size_t GetAnatomicRegionCount() const;
 
    void RemoveAnatomicRegion(std::size_t index);
 
    void SetPrimaryAnatomicStructure(const DICOMCodeSequenceWithModifiers& code, std::size_t index = 0);
 
    DICOMCodeSequenceWithModifiers GetPrimaryAnatomicStructure(std::size_t index = 0) const;
 
    std::size_t GetPrimaryAnatomicStructureCount() const;
 
    void RemovePrimaryAnatomicStructure(std::size_t index);
 
    void SetSegmentedPropertyCategory(const DICOMCodeSequence& code);
 
    std::optional<DICOMCodeSequence> GetSegmentedPropertyCategory() const;
 
    void SetSegmentedPropertyType(const DICOMCodeSequenceWithModifiers& code);
 
    std::optional<DICOMCodeSequenceWithModifiers> GetSegmentedPropertyType() const;
 
    void SetProperty(const std::string &propertyKey, BaseProperty *property, const std::string &contextName = "", bool fallBackOnDefaultContext = false) override;
 
    BaseProperty::ConstPointer GetConstProperty(const std::string& propertyKey, const std::string& contextName = "", bool fallBackOnDefaultContext = true) const override;
 
    BaseProperty* GetNonConstProperty(const std::string& propertyKey, const std::string& contextName = "", bool fallBackOnDefaultContext = true) override;
 
    using itk::Object::Modified;
    void Modified() { Superclass::Modified(); }
 
    void Update(const Label* templateLabel, bool updateLabelValue = false);
 
    Label();
 
    Label(PixelType value, const std::string& name);
 
    ~Label() override;
 
  protected:
    void PrintSelf(std::ostream &os, itk::Indent indent) const override;
    using PropertyList::GetProperty;
 
    Label(const Label &other);
 
    mitkCloneMacro(Label);
 
    void SetCenterOfMassIndex(const mitk::Point3D& center);
    void SetCenterOfMassCoordinates(const mitk::Point3D& center);
 
  private:
    PixelType m_Value;
 
    void SetDICOMCodeSequenceAsProperties(const PropertyKeyPath& basePath,
      const DICOMCodeSequence& code,
      bool withModifiers);
 
    std::optional<DICOMCodeSequence> GetDICOMCodeSequenceFromProperties(const PropertyKeyPath& basePath) const;
 
    std::optional<DICOMCodeSequenceWithModifiers> GetDICOMCodeSequenceWithModifiersFromProperties(const PropertyKeyPath& basePath) const;
 
    void RemoveDICOMCodeSequenceProperties(const PropertyKeyPath& basePath);
  };
 
  using LabelVector = std::vector<Label::Pointer>;
 
  using ConstLabelVector = std::vector<Label::ConstPointer>;
 
  MITKMULTILABEL_EXPORT bool Equal(const mitk::Label &leftHandSide,
                                   const mitk::Label &rightHandSide,
                                   ScalarType eps,
                                   bool verbose);
 
} // namespace mitk
 
#endif