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;

    using mitk::Image::Initialize;
    void Initialize(const mitk::Image *image) override;

    void Concatenate(mitk::LabelSetImage *image);

    void ClearBuffer();

    void MergeLabel(PixelType pixelValue, PixelType sourcePixelValue, unsigned int layer = 0);

    void MergeLabels(PixelType pixelValue, std::vector<PixelType>& vectorOfSourcePixelValues, unsigned int layer = 0);

    void UpdateCenterOfMass(PixelType pixelValue, unsigned int layer = 0);

    void RemoveLabels(std::vector<PixelType> &VectorOfLabelPixelValues, unsigned int layer = 0);

    void EraseLabel(PixelType pixelValue, unsigned int layer = 0);

    void EraseLabels(std::vector<PixelType> &VectorOfLabelPixelValues, unsigned int layer = 0);

    bool ExistLabel(PixelType pixelValue) const;

    bool ExistLabel(PixelType pixelValue, unsigned int layer) const;

    bool ExistLabelSet(unsigned int layer) const;

    mitk::Label *GetActiveLabel(unsigned int layer = 0);

    mitk::Label *GetLabel(PixelType pixelValue, unsigned int layer = 0) const;

    mitk::LabelSet *GetActiveLabelSet();

    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 layer = nullptr);

    unsigned int AddLayer(mitk::Image::Pointer layerImage, mitk::LabelSet::Pointer lset = nullptr);

    void AddLabelSetToLayer(const unsigned int layerIdx, const mitk::LabelSet::Pointer labelSet);

    void RemoveLayer();

    mitk::Image *GetLayerImage(unsigned int layer);

    const mitk::Image *GetLayerImage(unsigned int layer) const;

    void OnLabelSetModified();

    void SetExteriorLabel(mitk::Label *label);

    mitk::Label *GetExteriorLabel();

    const mitk::Label *GetExteriorLabel() const;

  protected:
    mitkCloneMacro(Self);

      LabelSetImage();
    LabelSetImage(const LabelSetImage &other);
    ~LabelSetImage() override;

    template <typename ImageType1, typename ImageType2>
    void ChangeLayerProcessing(ImageType1 *source, ImageType2 *target);

    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, unsigned int layer);

    //  template < typename ImageType >
    //  void ReorderLabelProcessing( ImageType* input, int index, int layer);

    template <typename ImageType>
    void MergeLabelProcessing(ImageType *input, PixelType pixelValue, PixelType index);

    template <typename ImageType>
    void ConcatenateProcessing(ImageType *input, mitk::LabelSetImage *other);

    template <typename ImageType>
    void MaskStampProcessing(ImageType *input, mitk::Image *mask, bool forceOverwrite);

    template <typename LabelSetImageType, typename ImageType>
    void InitializeByLabeledImageProcessing(LabelSetImageType *input, ImageType *other);

    std::vector<LabelSet::Pointer> m_LabelSetContainer;
    std::vector<Image::Pointer> m_LayerContainer;

    int m_ActiveLayer;

    bool m_activeLayerInvalid;

    mitk::Label::Pointer m_ExteriorLabel;
  };

  MITKMULTILABEL_EXPORT bool Equal(const mitk::LabelSetImage &leftHandSide,
                                   const mitk::LabelSetImage &rightHandSide,
                                   ScalarType eps,
                                   bool verbose);

} // namespace mitk

#endif // __mitkLabelSetImage_H_