mitkNonBlockingAlgorithm.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 mitkNonBlockingAlgorithm_h
#define mitkNonBlockingAlgorithm_h
 
#include "MitkAlgorithmsExtExports.h"
#include <itkImage.h>
#include <itkMacro.h>
#include <itkObjectFactory.h>
 
#include "mitkCommon.h"
#include "mitkDataStorage.h"
#include "mitkProperties.h"
#include "mitkPropertyList.h"
#include "mitkSmartPointerProperty.h"
#include "mitkWeakPointer.h"
 
#include "mitkImage.h"
#include "mitkSurface.h"
 
#include <mutex>
#include <stdexcept>
#include <string>
 
#define mitkAlgorithmNewMacro(classname)                                                                               \
  \
static Pointer                                                                                                         \
    New(void)                                                                                                          \
  {                                                                                                                    \
    classname *rawPtr = new classname();                                                                               \
    Pointer smartPtr = rawPtr;                                                                                         \
    rawPtr->UnRegister();                                                                                              \
    rawPtr->Initialize();                                                                                              \
    return smartPtr;                                                                                                   \
  \
}                                                                                                                 \
  \
virtual::itk::LightObject::Pointer                                                                                     \
    CreateAnother(void) const override                                                                                 \
  \
{                                                                                                                 \
    Pointer smartPtr = classname::New();                                                                               \
    ::itk::LightObject::Pointer lightPtr = smartPtr.GetPointer();                                                      \
    smartPtr->Initialize(this);                                                                                        \
    return lightPtr;                                                                                                   \
  \
}
 
namespace mitk
{
  class MITKALGORITHMSEXT_EXPORT NonBlockingAlgorithm : public itk::Object
  {
  public:
    mitkClassMacroItkParent(NonBlockingAlgorithm, itk::Object);
 
    void SetDataStorage(DataStorage &storage);
    DataStorage *GetDataStorage();
 
    // parameter setting
 
    template <typename T>
    void SetParameter(const char *parameter, const T &value)
    {
      // MITK_INFO << "SetParameter(" << parameter << ") " << typeid(T).name() << std::endl;
      // m_ParameterListMutex->Lock();
      m_Parameters->SetProperty(parameter, GenericProperty<T>::New(value));
      // m_ParameterListMutex->Unlock();
    }
 
    template <typename T>
    void SetPointerParameter(const char *parameter, const itk::SmartPointer<T> &value)
    {
      // MITK_INFO << this << "->SetParameter smartpointer(" << parameter << ") " << typeid(itk::SmartPointer<T>).name()
      // << std::endl;
      m_ParameterListMutex.lock();
      m_Parameters->SetProperty(parameter, SmartPointerProperty::New(value.GetPointer()));
      m_ParameterListMutex.unlock();
    }
    // virtual void SetParameter( const char*, mitk::BaseProperty* ); // for "number of iterations", ...
    // create some property observing to inform algorithm object about changes
    // perhaps some TriggerParameter(string) macro that creates an observer for changes in a specific property like
    // "2ndPoint" for LineAlgorithms
 
    void SetPointerParameter(const char *parameter, BaseData *value);
 
    template <typename TPixel, unsigned int VImageDimension>
    void SetItkImageAsMITKImagePointerParameter(const char *parameter, itk::Image<TPixel, VImageDimension> *itkImage)
    {
      // MITK_INFO << "SetParameter ITK image(" << parameter << ") " << typeid(itk::Image<TPixel,
      // VImageDimension>).name() << std::endl;
      // create an MITK image for that
      mitk::Image::Pointer mitkImage = mitk::Image::New();
      mitkImage = ImportItkImage(itkImage);
      SetPointerParameter(parameter, mitkImage);
    }
 
    template <typename TPixel, unsigned int VImageDimension>
    void SetItkImageAsMITKImagePointerParameter(const char *parameter,
                                                const itk::SmartPointer<itk::Image<TPixel, VImageDimension>> &itkImage)
    {
      // MITK_INFO << "SetParameter ITK image(" << parameter << ") " << typeid(itk::SmartPointer<itk::Image<TPixel,
      // VImageDimension> >).name() << std::endl;
      // create an MITK image for that
      mitk::Image::Pointer mitkImage = mitk::Image::New();
      mitkImage = ImportItkImage(itkImage);
      SetPointerParameter(parameter, mitkImage);
    }
 
    // parameter getting
 
    template <typename T>
    void GetParameter(const char *parameter, T &value) const
    {
      // MITK_INFO << "GetParameter normal(" << parameter << ") " << typeid(T).name() << std::endl;
      // m_ParameterListMutex->Lock();
      BaseProperty *p = m_Parameters->GetProperty(parameter);
      GenericProperty<T> *gp = dynamic_cast<GenericProperty<T> *>(p);
      if (gp)
      {
        value = gp->GetValue();
        // m_ParameterListMutex->Unlock();
        return;
      }
      // m_ParameterListMutex->Unlock();
 
      std::string error("There is no parameter \"");
      error += parameter;
      error += '"';
      throw std::invalid_argument(error);
    }
 
    template <typename T>
    void GetPointerParameter(const char *parameter, itk::SmartPointer<T> &value) const
    {
      // MITK_INFO << this << "->GetParameter smartpointer(" << parameter << ") " << typeid(itk::SmartPointer<T>).name()
      // << std::endl;
      // m_ParameterListMutex->Lock();
      BaseProperty *p = m_Parameters->GetProperty(parameter);
      if (p)
      {
        SmartPointerProperty *spp = dynamic_cast<SmartPointerProperty *>(p);
        if (spp)
        {
          T *t = dynamic_cast<T *>(spp->GetSmartPointer().GetPointer());
          value = t;
          // m_ParameterListMutex->Unlock();
          return;
        }
      }
      // m_ParameterListMutex->Unlock();
 
      std::string error("There is no parameter \"");
      error += parameter;
      error += '"';
      throw std::invalid_argument(error);
    }
 
    // start/stop functions
 
    virtual void Reset();
 
    void StartAlgorithm();         // for those who want to trigger calculations on their own
                                   // --> need for an OPTION: manual/automatic starting
    void StartBlockingAlgorithm(); // for those who want to trigger calculations on their own
    void StopAlgorithm();
 
    void TriggerParameterModified(const itk::EventObject &);
 
    void ThreadedUpdateSuccessful(const itk::EventObject &);
    void ThreadedUpdateFailed(const itk::EventObject &);
 
  protected:
    NonBlockingAlgorithm(); // use smart pointers
    ~NonBlockingAlgorithm() override;
 
    void DefineTriggerParameter(const char *);
    void UnDefineTriggerParameter(const char *);
 
    virtual void Initialize(const NonBlockingAlgorithm *other = nullptr);
    virtual bool ReadyToRun();
 
    virtual bool ThreadedUpdateFunction();   // will be called from a thread after calling StartAlgorithm
    virtual void ThreadedUpdateSuccessful(); // will be called after the ThreadedUpdateFunction() returned
    virtual void ThreadedUpdateFailed();     // will when ThreadedUpdateFunction() returns false
 
    PropertyList::Pointer m_Parameters;
 
    WeakPointer<DataStorage> m_DataStorage;
 
  private:
    static void StaticNonBlockingAlgorithmThread(NonBlockingAlgorithm* algorithm);
 
    typedef std::map<std::string, unsigned long> MapTypeStringUInt;
 
    MapTypeStringUInt m_TriggerPropertyConnections;
 
    std::mutex m_ParameterListMutex;
 
    int m_UpdateRequests;
    std::thread m_Thread;
 
    bool m_KillRequest;
  };
 
} // namespace
 
#include "mitkNonBlockingAlgorithmEvents.h"
 
#endif