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 mitkMultiLabelSegmentation_h
#define mitkMultiLabelSegmentation_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 MultiLabelSegmentation : public SlicedData
  {
  public:
    Message<> AfterChangeLayerEvent;
 
    mitkClassMacro(MultiLabelSegmentation, SlicedData);
    itkNewMacro(Self);
 
    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;
    //* Returns the pixel type used in group images*/
    static PixelType GetPixelType();
 
    enum class MergeStyle
    {
      Replace, 
      Merge 
    };
 
    enum class OverwriteStyle
    {
      RegardLocks,
      IgnoreLocks
    };
 
    bool IsSliceSet(int s = 0, int t = 0, int n = 0) const override;
 
    bool IsVolumeSet(int t = 0, int n = 0) const override;
 
    bool IsChannelSet(int n = 0) const override;
 
    unsigned int GetDimension() const;
    using GroupImageDimensionVectorType = std::vector<unsigned int>;
    const GroupImageDimensionVectorType& GetDimensions() const;
 
    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 UpdateLabel(LabelValueType labelValue, const Label* templateLabel);
 
    void RemoveLabel(LabelValueType labelValue);
 
    void RemoveLabels(const LabelValueVectorType& vectorOfLabelPixelValues);
 
    void EraseLabel(LabelValueType labelValue);
 
    void EraseLabels(const LabelValueVectorType& labelValues);
 
    void MergeLabel(LabelValueType targetLabelValue, LabelValueType sourceLabelValue,
      OverwriteStyle overwriteStyle = OverwriteStyle::RegardLocks);
 
    void MergeLabels(LabelValueType targetLabelValue, const LabelValueVectorType& sourceLabelValues,
      OverwriteStyle overwriteStyle = OverwriteStyle::RegardLocks);
 
    GroupIndexType AddGroup(ConstLabelVector labels = {});
 
    GroupIndexType AddGroup(mitk::Image* layerImage, ConstLabelVector labels = {});
 
    void InsertGroup(GroupIndexType groupID, ConstLabelVector labels = {}, std::string name = "");
 
    void InsertGroup(GroupIndexType groupID, mitk::Image* layerImage, ConstLabelVector labels = {}, std::string name = "");
 
    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;
 
    mitk::Label::ConstPointer GetLabel(LabelValueType value) const;
    mitk::Label::Pointer 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(const std::string_view name) const;
 
    const LabelValueVectorType GetLabelValuesByName(GroupIndexType index, const std::string_view name) const;
 
    const LabelValueVectorType GetLabelValuesByCoordinates(const Point3D& coordinates, TimeStepType timeStep = 0,
      std::optional<GroupIndexType> index = std::make_optional<GroupIndexType>()) 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);
 
    void ReplaceGroupLabels(std::map<MultiLabelSegmentation::GroupIndexType, MultiLabelSegmentation::ConstLabelVectorType> newGroupLabels);
 
    void ReplaceLabels(const ConstLabelVectorType& labelsUpdates);
 
    void ReplaceLabels(const LabelVectorType& newLabels);
 
    mitk::Image* GetGroupImage(GroupIndexType groupID);
 
    const mitk::Image* GetGroupImage(GroupIndexType groupID) const;
 
    void UpdateGroupImage(GroupIndexType groupID, const mitk::Image* sourceImage, TimeStepType timestep, TimeStepType sourceTimestep = 0);
 
    void ClearGroupImage(GroupIndexType groupID);
     void ClearGroupImage(GroupIndexType groupID, TimeStepType timestep);
 
    void ClearGroupImages();
    void ClearGroupImages(TimeStepType timestep);
 
    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(LabelValueType pixelValue);
 
    void Initialize() override;
 
    void Initialize(const mitk::Image* templateImage, bool resetLabels = true, bool ensure1stGroup = true);
 
    void Initialize(const mitk::TimeGeometry* geometry, bool resetLabels = true, bool ensure1stGroup = true);
 
    void InitializeByLabeledImage(const mitk::Image* image);
 
    itk::ModifiedTimeType GetMTime() const override;
 
    void UpdateCenterOfMass(LabelValueType pixelValue);
 
    using BaseData::IsEmpty;
 
    bool IsEmpty(const Label* label, TimeStepType t = 0) const;
    bool IsEmpty(LabelValueType pixelValue, TimeStepType t = 0) const;
 
    unsigned int GetActiveLayer() const;
 
    void SetActiveLabel(LabelValueType label);
    Label* GetActiveLabel();
    const Label* GetActiveLabel() const;
 
    unsigned int GetNumberOfLabels(unsigned int group) const;
 
    unsigned int GetTotalNumberOfLabels() const;
 
    unsigned int GetNumberOfGroups() const;
 
  protected:
    mitkCloneMacro(Self);
 
    MultiLabelSegmentation();
    MultiLabelSegmentation(const MultiLabelSegmentation& other);
    ~MultiLabelSegmentation() override;
 
    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;
 
    template <typename ImageType>
    void CalculateCenterOfMassProcessing(ImageType* input, LabelValueType index);
 
    template <typename ImageType>
    void EraseLabelProcessing(ImageType* input, LabelValueType index);
 
    template <typename MultiLabelSegmentationType, typename ImageType>
    void InitializeByLabeledImageProcessing(MultiLabelSegmentationType* input, const ImageType* other);
 
    LabelValueVectorType GetUsedLabelValues() const;
 
  private:
    Image::Pointer GenerateNewGroupImage() const;
 
    std::vector<Image::Pointer> m_GroupContainer;
 
    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;
 
    GroupImageDimensionVectorType m_GroupImageDimensions;
  };
 
  MITKMULTILABEL_EXPORT bool Equal(const mitk::MultiLabelSegmentation &leftHandSide,
                                   const mitk::MultiLabelSegmentation &rightHandSide,
                                   ScalarType eps,
                                   bool verbose);
 
  MITKMULTILABEL_EXPORT bool Equal(const mitk::MultiLabelSegmentation::ConstLabelVectorType& leftHandSide,
    const mitk::MultiLabelSegmentation::ConstLabelVectorType& rightHandSide,
    ScalarType eps,
    bool verbose);
 
  MITKMULTILABEL_EXPORT bool Equal(const mitk::MultiLabelSegmentation::LabelValueVectorType& leftHandSide,
    const mitk::MultiLabelSegmentation::LabelValueVectorType& rightHandSide,
    bool orderIsRelevant = false);
 
 
  using LabelValueMappingVector = std::vector < std::pair<Label::PixelType, Label::PixelType> >;
 
  MITKMULTILABEL_EXPORT void TransferLabelContentAtTimeStep(const MultiLabelSegmentation* sourceImage, MultiLabelSegmentation* 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 MultiLabelSegmentation* sourceImage, MultiLabelSegmentation* 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 = MultiLabelSegmentation::UNLABELED_VALUE,
    mitk::Label::PixelType destinationBackground = MultiLabelSegmentation::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 = MultiLabelSegmentation::UNLABELED_VALUE,
    mitk::Label::PixelType destinationBackground = MultiLabelSegmentation::UNLABELED_VALUE,
    bool destinationBackgroundLocked = false,
    LabelValueMappingVector labelMapping = { {1,1} },
    MultiLabelSegmentation::MergeStyle mergeStyle = MultiLabelSegmentation::MergeStyle::Replace,
    MultiLabelSegmentation::OverwriteStyle overwriteStlye = MultiLabelSegmentation::OverwriteStyle::RegardLocks);
 
} // namespace mitk
 
#endif