mitkLabelSetImage.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 mitkLabelSetImage_h
#define mitkLabelSetImage_h
 
#include <shared_mutex>
#include <mitkImage.h>
#include <mitkLabel.h>
#include <mitkLookupTable.h>
#include <mitkMultiLabelEvents.h>
#include <mitkMessage.h>
#include <mitkITKEventObserverGuard.h>
 
#include <MitkMultilabelExports.h>
 
namespace mitk
{
  class MITKMULTILABEL_EXPORT LabelSetImage : public Image
  {
  public:
    Message<> BeforeChangeLayerEvent;
 
    Message<> AfterChangeLayerEvent;
 
    // FUTURE MultiLabelSegmentation:
    // Section that already contains declarations used in the new class.
    // So this part of the interface will stay after refactoring towards
    // the new MultiLabelSegmentation class (see T28524). This section was introduced
    // because some of the planned features are already urgently needed.
    mitkClassMacro(LabelSetImage, Image);
    itkNewMacro(Self);
 
    typedef mitk::Label::PixelType PixelType;
 
    using GroupIndexType = std::size_t;
    using LabelValueType = mitk::Label::PixelType;
    using ConstLabelVectorType = ConstLabelVector;
    using LabelVectorType = LabelVector;
    using LabelValueVectorType = std::vector<LabelValueType>;
 
    const static LabelValueType UNLABELED_VALUE;
 
    mitk::Label* AddLabel(Label* label, GroupIndexType groupID, bool addAsClone = true, bool correctLabelValue = true);
 
    mitk::Label* AddLabelWithContent(Label* label, const Image* labelContent, GroupIndexType groupID, LabelValueType contentLabelValue, bool addAsClone = true, bool correctLabelValue = true);
 
    mitk::Label* AddLabel(const std::string& name, const Color& color, GroupIndexType groupID);
 
    void RenameLabel(LabelValueType labelValue, const std::string& name, const Color& color);
 
    void RemoveLabel(LabelValueType labelValue);
 
    void RemoveLabels(const LabelValueVectorType& vectorOfLabelPixelValues);
 
    void EraseLabel(LabelValueType labelValue);
 
    void EraseLabels(const LabelValueVectorType& labelValues);
 
    void RemoveGroup(GroupIndexType group);
 
    bool ExistLabel(LabelValueType value) const;
 
    bool ExistLabel(LabelValueType value, GroupIndexType groupIndex) const;
 
    bool ExistGroup(GroupIndexType index) const;
 
    GroupIndexType GetGroupIndexOfLabel(LabelValueType value) const;
 
    const mitk::Label* GetLabel(LabelValueType value) const;
    mitk::Label* GetLabel(LabelValueType value);
 
    const ConstLabelVectorType GetLabels() const;
    const LabelVectorType GetLabels();
 
    const LabelValueVectorType GetAllLabelValues() const;
 
    const LabelVectorType GetLabelsByValue(const LabelValueVectorType& labelValues, bool ignoreMissing = true);
 
    const ConstLabelVectorType GetConstLabelsByValue(const LabelValueVectorType& labelValues, bool ignoreMissing = false) const;
 
    static LabelValueVectorType ExtractLabelValuesFromLabelVector(const ConstLabelVectorType& labels);
    static LabelValueVectorType ExtractLabelValuesFromLabelVector(const LabelVectorType& labels);
 
    static ConstLabelVectorType ConvertLabelVectorConst(const LabelVectorType& labels);
 
    const LabelValueVectorType GetLabelValuesByGroup(GroupIndexType index) const;
 
    const LabelValueVectorType GetLabelValuesByName(GroupIndexType index, const std::string_view name) const;
 
    std::vector<std::string> GetLabelClassNames() const;
 
    std::vector<std::string> GetLabelClassNamesByGroup(GroupIndexType index) const;
 
    LabelValueType GetUnusedLabelValue() const;
 
    itkGetConstMacro(UnlabeledLabelLock, bool);
    itkSetMacro(UnlabeledLabelLock, bool);
    itkBooleanMacro(UnlabeledLabelLock);
 
    void SetAllLabelsVisible(bool visible);
 
    void SetAllLabelsVisibleByGroup(GroupIndexType group, bool visible);
 
    void SetAllLabelsVisibleByName(GroupIndexType group, const std::string_view name, bool visible);
 
    bool IsLabelLocked(LabelValueType value) const;
 
    void SetAllLabelsLocked(bool locked);
 
    void SetAllLabelsLockedByGroup(GroupIndexType group, bool locked);
 
    void SetAllLabelsLockedByName(GroupIndexType group, const std::string_view name, bool locked);
 
    void ReplaceGroupLabels(const GroupIndexType groupID, const ConstLabelVectorType& newLabels);
 
    void ReplaceGroupLabels(const GroupIndexType groupID, const LabelVectorType& newLabels);
 
    mitk::Image* GetGroupImage(GroupIndexType groupID);
 
    const mitk::Image* GetGroupImage(GroupIndexType groupID) const;
 
    const std::string& GetGroupName(GroupIndexType groupID) const;
 
    void SetGroupName(GroupIndexType groupID, const std::string& name);
 
    itkGetModifiableObjectMacro(LookupTable, mitk::LookupTable);
    void SetLookupTable(LookupTable* lut);
    void UpdateLookupTable(PixelType pixelValue);
 
    protected:
 
      void OnLabelModified(const Object* sender, const itk::EventObject&);
 
      void AddLabelToMap(LabelValueType labelValue, Label* label, GroupIndexType groupID);
      void RemoveLabelFromMap(LabelValueType labelValue);
      void RegisterLabel(Label* label);
      void ReleaseLabel(Label* label);
 
      void ApplyToLabels(const LabelValueVectorType& values, std::function<void(Label*)>&& lambda);
      void VisitLabels(const LabelValueVectorType& values, std::function<void(const Label*)>&& lambda) const;
 
      LabelValueType m_ActiveLabelValue;
 
    private:
      using LabelMapType = std::map<LabelValueType, Label::Pointer>;
      LabelMapType m_LabelMap;
 
      using GroupNameVectorType = std::vector<std::string>;
      GroupNameVectorType m_Groups;
 
      using GroupToLabelMapType = std::vector<LabelValueVectorType>;
      /* Dictionary that maps between group id (key) and label values in the group (vector of label value).*/
      GroupToLabelMapType m_GroupToLabelMap;
      using LabelToGroupMapType = std::map<LabelValueType, GroupIndexType>;
      /* Dictionary that maps between label value (key) and group id (value)*/
      LabelToGroupMapType m_LabelToGroupMap;
 
      using LabelEventGuardMapType = std::map<LabelValueType, ITKEventObserverGuard>;
      LabelEventGuardMapType m_LabelModEventGuardMap;
 
      LookupTable::Pointer m_LookupTable;
 
      bool m_UnlabeledLabelLock;
 
      std::shared_mutex m_LabelNGroupMapsMutex;
 
    public:
 
 
    // END FUTURE MultiLabelSegmentation
 
      const mitk::Image* GetGroupImageWorkaround(GroupIndexType groupID) const;
 
      void UpdateCenterOfMass(PixelType pixelValue);
 
    using mitk::Image::Initialize;
    void Initialize(const mitk::Image *image) override;
 
    void ClearBuffer();
 
    void MergeLabel(PixelType pixelValue, PixelType sourcePixelValue);
 
    void MergeLabels(PixelType pixelValue, const std::vector<PixelType>& vectorOfSourcePixelValues);
 
    unsigned int GetActiveLayer() const;
 
    Label* GetActiveLabel();
 
    const Label* GetActiveLabel() const;
 
    unsigned int GetNumberOfLabels(unsigned int layer) const;
 
    unsigned int GetTotalNumberOfLabels() const;
 
    void InitializeByLabeledImage(mitk::Image::Pointer image);
 
    void MaskStamp(mitk::Image *mask, bool forceOverwrite);
 
    void SetActiveLayer(unsigned int layer);
    void SetActiveLabel(LabelValueType label);
 
    unsigned int GetNumberOfLayers() const;
 
    GroupIndexType AddLayer(ConstLabelVector labels = {});
 
    GroupIndexType AddLayer(mitk::Image* layerImage, ConstLabelVector labels = {});
 
  protected:
    mitkCloneMacro(Self);
 
      LabelSetImage();
    LabelSetImage(const LabelSetImage &other);
    ~LabelSetImage() override;
 
    template <typename TPixel, unsigned int VImageDimension>
    void LayerContainerToImageProcessing(itk::Image<TPixel, VImageDimension> *source, unsigned int layer);
 
    template <typename TPixel, unsigned int VImageDimension>
    void ImageToLayerContainerProcessing(const itk::Image<TPixel, VImageDimension> *source, unsigned int layer) const;
 
    template <typename ImageType>
    void CalculateCenterOfMassProcessing(ImageType *input, LabelValueType index);
 
    template <typename ImageType>
    void EraseLabelProcessing(ImageType *input, PixelType index);
 
    template <typename ImageType>
    void MergeLabelProcessing(ImageType *input, PixelType pixelValue, PixelType index);
 
    template <typename ImageType>
    void MaskStampProcessing(ImageType *input, mitk::Image *mask, bool forceOverwrite);
 
    template <typename LabelSetImageType, typename ImageType>
    void InitializeByLabeledImageProcessing(LabelSetImageType *input, ImageType *other);
 
    LabelValueVectorType GetUsedLabelValues() const;
 
    std::vector<Image::Pointer> m_LayerContainer;
 
    int m_ActiveLayer;
    bool m_activeLayerInvalid;
  };
 
  MITKMULTILABEL_EXPORT bool Equal(const mitk::LabelSetImage &leftHandSide,
                                   const mitk::LabelSetImage &rightHandSide,
                                   ScalarType eps,
                                   bool verbose);
 
  MITKMULTILABEL_EXPORT bool Equal(const mitk::LabelSetImage::ConstLabelVectorType& leftHandSide,
    const mitk::LabelSetImage::ConstLabelVectorType& rightHandSide,
    ScalarType eps,
    bool verbose);
 
 
  namespace MultiLabelSegmentation
  {
    enum class MergeStyle
    {
      Replace, //The old label content of a label value will be replaced by its new label content.
               //Therefore pixels that are labeled might become unlabeled again.
               //(This means that a lock of the value is also ignored).
      Merge //The union of old and new label content will be generated.
    };
 
    enum class OverwriteStyle
    {
      RegardLocks, //Locked labels in the same spatial group will not be overwritten/changed.
      IgnoreLocks //Label locks in the same spatial group will be ignored, so these labels might be changed.
    };
  }
 
  using LabelValueMappingVector = std::vector < std::pair<Label::PixelType, Label::PixelType> >;
 
  MITKMULTILABEL_EXPORT void TransferLabelContentAtTimeStep(const LabelSetImage* sourceImage, LabelSetImage* destinationImage,
    const TimeStepType timeStep, LabelValueMappingVector labelMapping = { {1,1} },
    MultiLabelSegmentation::MergeStyle mergeStyle = MultiLabelSegmentation::MergeStyle::Replace,
    MultiLabelSegmentation::OverwriteStyle overwriteStlye = MultiLabelSegmentation::OverwriteStyle::RegardLocks);
 
  MITKMULTILABEL_EXPORT void TransferLabelContent(const LabelSetImage* sourceImage, LabelSetImage* destinationImage, LabelValueMappingVector labelMapping = { {1,1} },
    MultiLabelSegmentation::MergeStyle mergeStyle = MultiLabelSegmentation::MergeStyle::Replace,
    MultiLabelSegmentation::OverwriteStyle overwriteStlye = MultiLabelSegmentation::OverwriteStyle::RegardLocks);
 
 
  MITKMULTILABEL_EXPORT void TransferLabelContentAtTimeStep(const Image* sourceImage, Image* destinationImage, const mitk::ConstLabelVector& destinationLabelVector,
    const TimeStepType timeStep, mitk::Label::PixelType sourceBackground = LabelSetImage::UNLABELED_VALUE,
    mitk::Label::PixelType destinationBackground = LabelSetImage::UNLABELED_VALUE,
    bool destinationBackgroundLocked = false,
    LabelValueMappingVector labelMapping = { {1,1} },
    MultiLabelSegmentation::MergeStyle mergeStyle = MultiLabelSegmentation::MergeStyle::Replace,
    MultiLabelSegmentation::OverwriteStyle overwriteStlye = MultiLabelSegmentation::OverwriteStyle::RegardLocks);
 
  MITKMULTILABEL_EXPORT void TransferLabelContent(const Image* sourceImage, Image* destinationImage, const mitk::ConstLabelVector& destinationLabelVector,
    mitk::Label::PixelType sourceBackground = LabelSetImage::UNLABELED_VALUE,
    mitk::Label::PixelType destinationBackground = LabelSetImage::UNLABELED_VALUE,
    bool destinationBackgroundLocked = false,
    LabelValueMappingVector labelMapping = { {1,1} },
    MultiLabelSegmentation::MergeStyle mergeStyle = MultiLabelSegmentation::MergeStyle::Replace,
    MultiLabelSegmentation::OverwriteStyle overwriteStlye = MultiLabelSegmentation::OverwriteStyle::RegardLocks);
 
} // namespace mitk
 
#endif