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