mitkAnnotation.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 Annotation_H
#define Annotation_H

#include "mitkServiceInterface.h"
#include "usServiceRegistration.h"
#include <MitkCoreExports.h>
#include <mitkBaseRenderer.h>
#include <mitkCommon.h>

namespace mitk
{
  class MITKCORE_EXPORT Annotation : public itk::Object
  {
  public:
    struct Bounds
    {
      itk::Point<double, 2> Position;
      itk::Point<double, 2> Size;
    };

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

      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);

    void ReplaceProperty(const std::string &propertyKey, const BaseProperty::Pointer &property);

    void AddProperty(const std::string &propertyKey, const BaseProperty::Pointer &property, bool overwrite = false);

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

    mitk::BaseProperty *GetProperty(const std::string &propertyKey) const;

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

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

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

    bool GetBoolProperty(const std::string &propertyKey, bool &boolValue) const;

    bool GetIntProperty(const std::string &propertyKey, int &intValue) const;

    bool GetFloatProperty(const std::string &propertyKey, float &floatValue) const;

    bool GetDoubleProperty(const std::string &propertyKey, double &doubleValue) const;

    bool GetStringProperty(const std::string &propertyKey, std::string &string) const;

    void SetIntProperty(const std::string &propertyKey, int intValue);

    void SetBoolProperty(const std::string &propertyKey, bool boolValue);

    void SetFloatProperty(const std::string &propertyKey, float floatValue);

    void SetDoubleProperty(const std::string &propertyKey, double doubleValue);

    void SetStringProperty(const std::string &propertyKey, const std::string &string);

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

    bool GetName(std::string &nodeName, const std::string &propertyKey = "name") const;

    virtual std::string GetName() const;

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

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

    void SetText(std::string text);

    std::string GetText() const;

    void SetFontSize(int fontSize);

    int GetFontSize() const;

    bool GetVisibility(bool &visible, const std::string &propertyKey = "visible") const;

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

    void SetVisibility(bool visible, 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;

    PropertyList *GetPropertyList() const;

    std::string GetMicroserviceID();

    static const std::string US_INTERFACE_NAME;
    static const std::string US_PROPKEY_AnnotationNAME;
    static const std::string US_PROPKEY_ID;
    static const std::string US_PROPKEY_MODIFIED;
    static const std::string US_PROPKEY_RENDERER_ID;
    static const std::string US_PROPKEY_AR_ID;

    virtual void RegisterAsMicroservice(us::ServiceProperties props);

    virtual void UnRegisterMicroservice();

    void AnnotationModified();

    mitkClassMacroItkParent(Annotation, itk::Object);

  protected:
    Annotation();

    ~Annotation() override;

    PropertyList::Pointer m_PropertyList;

    itk::TimeStamp m_DataReferenceChangedTime;

    void SetUSProperty(const std::string &propertyKey, us::Any value);

  private:
    bool m_ForceInForeground;

    Annotation(const Annotation &);

    Annotation &operator=(const Annotation &);

  private:
    us::ServiceRegistration<Self> m_ServiceRegistration;

    unsigned long m_PropertyListModifiedObserverTag;
    void PropertyListModified(const itk::Object *, const itk::EventObject &);
  };

} // namespace mitk

MITK_DECLARE_SERVICE_INTERFACE(mitk::Annotation, "org.mitk.services.Annotation")

#endif // Annotation_H