mitkOverlay.h

Go to the documentation of this file.

/*===================================================================

The Medical Imaging Interaction Toolkit (MITK)

Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.

This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.

See LICENSE.txt or http://www.mitk.org for details.

===================================================================*/

#ifndef OVERLAY_H
#define OVERLAY_H

#include <MitkCoreExports.h>
#include <mitkBaseRenderer.h>
#include <mitkCommon.h>

namespace mitk
{
  class AbstractOverlayLayouter;

  class MITKCORE_EXPORT Overlay : public itk::Object
  {
    friend class AbstractOverlayLayouter;

  public:
    struct Bounds
    {
      itk::Point<double, 2> Position;
      itk::Point<double, 2> Size;
    };

    typedef std::map<const BaseRenderer *, PropertyList::Pointer> MapOfPropertyLists;

    class MITKCORE_EXPORT BaseLocalStorage
    {
    public:
      bool IsGenerateDataRequired(mitk::BaseRenderer *renderer, mitk::Overlay *overlay);

      inline void UpdateGenerateDataTime() { m_LastGenerateDataTime.Modified(); }
      inline itk::TimeStamp &GetLastGenerateDataTime() { return m_LastGenerateDataTime; }
    protected:
      itk::TimeStamp m_LastGenerateDataTime;
    };

    void SetProperty(const std::string &propertyKey,
                     const BaseProperty::Pointer &property,
                     const mitk::BaseRenderer *renderer = nullptr);

    void ReplaceProperty(const std::string &propertyKey,
                         const BaseProperty::Pointer &property,
                         const mitk::BaseRenderer *renderer = nullptr);

    void AddProperty(const std::string &propertyKey,
                     const BaseProperty::Pointer &property,
                     const mitk::BaseRenderer *renderer = nullptr,
                     bool overwrite = false);

    mitk::PropertyList *GetPropertyList(const mitk::BaseRenderer *renderer = nullptr) const;

    void ConcatenatePropertyList(PropertyList *pList, bool replace = false);

    mitk::BaseProperty *GetProperty(const std::string &propertyKey, const mitk::BaseRenderer *renderer = nullptr) const;

    template <typename T>
    bool GetProperty(itk::SmartPointer<T> &property,
                     const std::string &propertyKey,
                     const mitk::BaseRenderer *renderer = nullptr) const
    {
      property = dynamic_cast<T *>(GetProperty(propertyKey, renderer));
      return property.IsNotNull();
    }

    template <typename T>
    bool GetProperty(T *&property, const std::string &propertyKey, const mitk::BaseRenderer *renderer = nullptr) const
    {
      property = dynamic_cast<T *>(GetProperty(propertyKey, renderer));
      return property != nullptr;
    }

    template <typename T>
    bool GetPropertyValue(const std::string &propertyKey, T &value, mitk::BaseRenderer *renderer = nullptr) const
    {
      GenericProperty<T> *gp = dynamic_cast<GenericProperty<T> *>(GetProperty(propertyKey, renderer));
      if (gp != nullptr)
      {
        value = gp->GetValue();
        return true;
      }
      return false;
    }

    bool GetBoolProperty(const std::string &propertyKey, bool &boolValue, mitk::BaseRenderer *renderer = nullptr) const;

    bool GetIntProperty(const std::string &propertyKey, int &intValue, mitk::BaseRenderer *renderer = nullptr) const;

    bool GetFloatProperty(const std::string &propertyKey,
                          float &floatValue,
                          mitk::BaseRenderer *renderer = nullptr) const;

    bool GetStringProperty(const std::string &propertyKey,
                           std::string &string,
                           mitk::BaseRenderer *renderer = nullptr) const;

    void SetIntProperty(const std::string &propertyKey, int intValue, mitk::BaseRenderer *renderer = nullptr);

    void SetBoolProperty(const std::string &propertyKey, bool boolValue, mitk::BaseRenderer *renderer = nullptr);

    void SetFloatProperty(const std::string &propertyKey, float floatValue, mitk::BaseRenderer *renderer = nullptr);

    void SetStringProperty(const std::string &propertyKey,
                           const std::string &string,
                           mitk::BaseRenderer *renderer = nullptr);

    bool IsOn(const std::string &propertyKey, mitk::BaseRenderer *renderer, bool defaultIsOn = true) const
    {
      GetBoolProperty(propertyKey, defaultIsOn, renderer);
      return defaultIsOn;
    }

    bool GetName(std::string &nodeName,
                 mitk::BaseRenderer *renderer = nullptr,
                 const std::string &propertyKey = "name") const;

    virtual std::string GetName() const;

    virtual void SetName(const std::string &name);

    bool GetColor(float rgb[], mitk::BaseRenderer *renderer = nullptr, const std::string &propertyKey = "color") const;
    void SetColor(const mitk::Color &color,
                  mitk::BaseRenderer *renderer = nullptr,
                  const std::string &propertyKey = "color");
    void SetColor(float red,
                  float green,
                  float blue,
                  mitk::BaseRenderer *renderer = nullptr,
                  const std::string &propertyKey = "color");
    void SetColor(const float rgb[], mitk::BaseRenderer *renderer = nullptr, const std::string &propertyKey = "color");
    bool GetOpacity(float &opacity, mitk::BaseRenderer *renderer, const std::string &propertyKey = "opacity") const;
    void SetOpacity(float opacity, mitk::BaseRenderer *renderer = nullptr, const std::string &propertyKey = "opacity");

    void SetText(std::string text, mitk::BaseRenderer *renderer = nullptr);

    std::string GetText(mitk::BaseRenderer *renderer = nullptr) const;

    void SetFontSize(int fontSize, mitk::BaseRenderer *renderer = nullptr);

    int GetFontSize(mitk::BaseRenderer *renderer = nullptr) const;

    bool GetVisibility(bool &visible, mitk::BaseRenderer *renderer, const std::string &propertyKey = "visible") const;

    bool IsVisible(mitk::BaseRenderer *renderer,
                   const std::string &propertyKey = "visible",
                   bool defaultIsOn = true) const;

    void SetVisibility(bool visible,
                       mitk::BaseRenderer *renderer = nullptr,
                       const std::string &propertyKey = "visible");

    virtual void AddToBaseRenderer(BaseRenderer *renderer) = 0;

    virtual void AddToRenderer(BaseRenderer *renderer, vtkRenderer *vtkrenderer) = 0;

    virtual void RemoveFromBaseRenderer(BaseRenderer *renderer) = 0;

    virtual void RemoveFromRenderer(BaseRenderer *renderer, vtkRenderer *vtkrenderer) = 0;

    virtual void Update(BaseRenderer *renderer) = 0;

    virtual Bounds GetBoundsOnDisplay(BaseRenderer *renderer) const;

    virtual void SetBoundsOnDisplay(BaseRenderer *renderer, const Bounds &);

    void SetForceInForeground(bool forceForeground);

    bool IsForceInForeground() const;

    mitkClassMacroItkParent(Overlay, itk::Object);

  protected:
    Overlay();

    virtual ~Overlay();

    PropertyList::Pointer m_PropertyList;

    mutable MapOfPropertyLists m_MapOfPropertyLists;

    itk::TimeStamp m_DataReferenceChangedTime;

  private:
    bool m_ForceInForeground;

    Overlay(const Overlay &);

    Overlay &operator=(const Overlay &);

    AbstractOverlayLayouter *m_LayoutedBy;
  };

} // namespace mitk
#endif // OVERLAY_H