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 <mitkImage.h>
#include <mitkLabelSet.h>
 
#include <MitkMultilabelExports.h>
 
namespace mitk
{
  //##Documentation
  //## @brief LabelSetImage class for handling labels and layers in a segmentation session.
  //##
  //## Handles operations for adding, removing, erasing and editing labels and layers.
  //## @ingroup Data
 
  class MITKMULTILABEL_EXPORT LabelSetImage : public Image
  {
  public:
    mitkClassMacro(LabelSetImage, Image);
    itkNewMacro(Self);
 
    typedef mitk::Label::PixelType PixelType;
 
    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.
 
    using GroupIndexType = std::size_t;
    using LabelValueType = mitk::Label::PixelType;
    const static LabelValueType UnlabeledValue = 0;
    using ConstLabelVectorType = std::vector<Label::ConstPointer>;
    using LabelVectorType = std::vector<Label::Pointer>;
    using LabelValueVectorType = std::vector<LabelValueType>;
 
    void RemoveLabel(LabelValueType labelValue);
 
    void RemoveLabels(const LabelValueVectorType& vectorOfLabelPixelValues);
 
    void RemoveGroup(GroupIndexType group);
 
    //future declaration (T28524) currently conflicted with old declaration
    //  * \brief  Returns true if the value exists in the MultiLabelSegmentation instance*/
    //bool ExistLabel(LabelValueType value) const;
 
    // * @brief Checks if a label belongs in a certain spatial group
    // * @param value the label value
    // * @param groupIndex Indexp of the spacial group which should be checked for the label
    // * @return true if the label exists otherwise false
    // */
    //bool ExistLabel(LabelValueType value, GroupIndexType groupIndex) const;
 
    bool ExistGroup(GroupIndexType index) const;
 
    bool IsLabelInGroup(LabelValueType value) const;
    bool IsLabelInGroup(LabelValueType value, GroupIndexType& groupIndex) const;
 
    GroupIndexType GetGroupIndexOfLabel(LabelValueType value) const;
 
    const mitk::Label* GetLabel(LabelValueType value) const;
    mitk::Label* GetLabel(LabelValueType value);
 
    bool IsLabelLocked(LabelValueType value) const;
 
    const ConstLabelVectorType GetLabels() const;
    const LabelVectorType GetLabels();
 
    const ConstLabelVectorType GetLabelsInGroup(GroupIndexType index) const;
    const LabelVectorType GetLabelsInGroup(GroupIndexType index);
 
    itkGetConstMacro(UnlabeledLabelLock, bool);
    itkSetMacro(UnlabeledLabelLock, bool);
    itkBooleanMacro(UnlabeledLabelLock);
 
    //Message slots that allow to react to changes in an instance
 
    using LabelEventType = Message1<LabelValueType>;
    using LabelsEventType = Message1<LabelValueVectorType>;
    using GroupEventType = Message1<GroupIndexType>;
 
    mitkNewMessage1Macro(LabelAdded, LabelValueType);
 
    mitkNewMessage1Macro(LabelModified, LabelValueType);
 
    mitkNewMessage1Macro(LabelRemoved, LabelValueType);
 
    mitkNewMessage1Macro(LabelsChanged, LabelValueVectorType);
 
    mitkNewMessage1Macro(GroupAdded, GroupIndexType);
 
    mitkNewMessage1Macro(GroupModified, GroupIndexType);
 
    mitkNewMessage1Macro(GroupRemoved, GroupIndexType);
 
    protected:
 
      void OnLabelAdded(LabelValueType labelValue);
      void AddLabelToMap(LabelValueType labelValue, mitk::Label* label, GroupIndexType groupID);
      void OnLabelModified(LabelValueType labelValue);
      void OnLabelRemoved(LabelValueType labelValue);
      void OnGroupAdded(GroupIndexType groupIndex);
      void OnGroupModified(GroupIndexType groupIndex);
      void OnGroupRemoved(GroupIndexType groupIndex);
 
      void ReinitMaps();
 
      using LabelMapType = std::map<LabelValueType, Label::Pointer>;
      LabelMapType m_LabelMap;
 
      using GroupToLabelMapType = std::map<GroupIndexType, LabelValueVectorType>;
      GroupToLabelMapType m_GroupToLabelMap;
      using LabelToGroupMapType = std::map<LabelValueType, GroupIndexType>;
      LabelToGroupMapType m_LabelToGroupMap;
 
    private:
      bool m_UnlabeledLabelLock;
 
    public:
 
      void UpdateCenterOfMass(PixelType pixelValue);
 
    // END FUTURE MultiLabelSegmentation
 
    using mitk::Image::Initialize;
    void Initialize(const mitk::Image *image) override;
 
    void ClearBuffer();
 
    void MergeLabel(PixelType pixelValue, PixelType sourcePixelValue, unsigned int layer = 0);
 
    void MergeLabels(PixelType pixelValue, const std::vector<PixelType>& vectorOfSourcePixelValues, unsigned int layer = 0);
 
    void UpdateCenterOfMass(PixelType pixelValue, unsigned int layer);
 
    void EraseLabel(PixelType pixelValue);
 
    void EraseLabels(const std::vector<PixelType> &VectorOfLabelPixelValues);
 
    //[[deprecated("Will be changed with T28524")]]
    DEPRECATED(bool ExistLabel(PixelType pixelValue) const);
 
    //[[deprecated("Will be changed with T28524")]]
    DEPRECATED(bool ExistLabel(PixelType pixelValue, unsigned int layer) const);
 
    //[[deprecated("Will be removed with T28524")]]
    DEPRECATED(bool ExistLabelSet(unsigned int layer) const);
 
    //[[deprecated("Will be removed with T28524")]]
    DEPRECATED(mitk::Label *GetActiveLabel(unsigned int layer = 0));
    //[[deprecated("Will be removed with T28524")]]
    DEPRECATED(const mitk::Label* GetActiveLabel(unsigned int layer = 0) const);
 
    mitk::Label *GetLabel(PixelType pixelValue, unsigned int layer) const;
 
    //[[deprecated ("Will be removed with T28524")]]
    DEPRECATED(mitk::LabelSet *GetActiveLabelSet());
    //[[deprecated("Will be removed with T28524")]]
    DEPRECATED(const mitk::LabelSet* GetActiveLabelSet() const);
 
    mitk::LabelSet *GetLabelSet(unsigned int layer = 0);
    const mitk::LabelSet *GetLabelSet(unsigned int layer = 0) const;
 
    unsigned int GetActiveLayer() const;
 
    unsigned int GetNumberOfLabels(unsigned int layer = 0) const;
 
    unsigned int GetTotalNumberOfLabels() const;
 
    // This function will need to be ported to an external class
    // it requires knowledge of pixeltype and dimension and includes
    // too much algorithm to be sensibly part of a data class
    //  * \brief  */
    // void SurfaceStamp(mitk::Surface* surface, bool forceOverwrite);
 
    mitk::Image::Pointer CreateLabelMask(PixelType index, bool useActiveLayer = true, unsigned int layer = 0);
 
    void InitializeByLabeledImage(mitk::Image::Pointer image);
 
    void MaskStamp(mitk::Image *mask, bool forceOverwrite);
 
    void SetActiveLayer(unsigned int layer);
 
    unsigned int GetNumberOfLayers() const;
 
    unsigned int AddLayer(mitk::LabelSet::Pointer labelSet = nullptr);
 
    unsigned int AddLayer(mitk::Image::Pointer layerImage, mitk::LabelSet::Pointer labelSet = nullptr);
 
    void AddLabelSetToLayer(const unsigned int layerIdx, const mitk::LabelSet* labelSet);
 
    void RemoveLayer();
 
    mitk::Image *GetLayerImage(unsigned int layer);
 
    const mitk::Image *GetLayerImage(unsigned int layer) const;
 
    void OnLabelSetModified();
 
  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(itk::Image<TPixel, VImageDimension> *source, unsigned int layer) const;
 
    template <typename ImageType>
    void CalculateCenterOfMassProcessing(ImageType *input, PixelType index, unsigned int layer);
 
    template <typename ImageType>
    void ClearBufferProcessing(ImageType *input);
 
    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;
 
    //helper function that ensures
    void RegisterLabelSet(mitk::LabelSet* ls);
    void ReleaseLabelSet(mitk::LabelSet* ls);
 
    std::vector<LabelSet::Pointer> m_LabelSetContainer;
    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);
 
 
  namespace MultiLabelSegmentation
  {
    enum class MergeStyle
    {
      Replace, //The old label content of a lable 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.
    };
  }
 
  MITKMULTILABEL_EXPORT void TransferLabelContentAtTimeStep(const LabelSetImage* sourceImage, LabelSetImage* destinationImage,
    const TimeStepType timeStep, std::vector<std::pair<Label::PixelType, Label::PixelType> > labelMapping = { {1,1} },
    MultiLabelSegmentation::MergeStyle mergeStyle = MultiLabelSegmentation::MergeStyle::Replace,
    MultiLabelSegmentation::OverwriteStyle overwriteStlye = MultiLabelSegmentation::OverwriteStyle::RegardLocks);
 
  MITKMULTILABEL_EXPORT void TransferLabelContent(const LabelSetImage* sourceImage, LabelSetImage* destinationImage, std::vector<std::pair<Label::PixelType, Label::PixelType> > 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::LabelSet* destinationLabelSet,
    const TimeStepType timeStep, mitk::Label::PixelType sourceBackground = LabelSetImage::UnlabeledValue,
    mitk::Label::PixelType destinationBackground = LabelSetImage::UnlabeledValue,
    bool destinationBackgroundLocked = false,
    std::vector<std::pair<Label::PixelType, Label::PixelType> > 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::LabelSet* destinationLabelSet,
    mitk::Label::PixelType sourceBackground = LabelSetImage::UnlabeledValue,
    mitk::Label::PixelType destinationBackground = LabelSetImage::UnlabeledValue,
    bool destinationBackgroundLocked = false,
    std::vector<std::pair<Label::PixelType, Label::PixelType> > labelMapping = { {1,1} },
    MultiLabelSegmentation::MergeStyle mergeStyle = MultiLabelSegmentation::MergeStyle::Replace,
    MultiLabelSegmentation::OverwriteStyle overwriteStlye = MultiLabelSegmentation::OverwriteStyle::RegardLocks);
 
} // namespace mitk
 
#endif