mitkUSDevice.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 MITKUSDevice_H_HEADER_INCLUDED_
#define MITKUSDevice_H_HEADER_INCLUDED_

// STL
#include <vector>

// MitkUS
#include "mitkUSProbe.h"
#include <MitkUSExports.h>
#include "mitkUSImageSource.h"

// MitkIGTL
#include "mitkIGTLMessageProvider.h"
#include "mitkIGTLServer.h"
#include "mitkIGTLDeviceSource.h"
#include "mitkImageToIGTLMessageFilter.h"

// MITK
#include <mitkCommon.h>
#include <mitkMessage.h>
#include <mitkImageSource.h>

// ITK
#include <itkObjectFactory.h>
#include <itkConditionVariable.h>

// Microservices
#include <mitkServiceInterface.h>
#include <usServiceRegistration.h>
#include <usServiceProperties.h>

// DEPRECATED
#include "mitkUSImageMetadata.h"

namespace itk {
  template<class T> class SmartPointer;
}

namespace mitk {
  class USAbstractControlInterface;
  class USControlInterfaceBMode;
  class USControlInterfaceProbes;
  class USControlInterfaceDoppler;

  class MITKUS_EXPORT USDevice : public mitk::ImageSource
  {
  public:
    enum DeviceStates { State_NoState, State_Initialized, State_Connected, State_Activated };

    mitkClassMacro(USDevice, mitk::ImageSource);

    struct USImageCropArea
    {
      int cropLeft;
      int cropRight;
      int cropBottom;
      int cropTop;
    };

    struct PropertyKeys
    {
      const std::string US_INTERFACE_NAME;       // Common Interface name of all US Devices. Used to refer to this device via Microservices
      const std::string US_PROPKEY_MANUFACTURER;
      const std::string US_PROPKEY_NAME;
      const std::string US_PROPKEY_COMMENT;
      const std::string US_PROPKEY_LABEL;        // Human readable text represntation of this device
      const std::string US_PROPKEY_ISCONNECTED;  // Whether this device is connected or not.
      const std::string US_PROPKEY_ISACTIVE;     // Whether this device is active or not.
      const std::string US_PROPKEY_CLASS;        // Class Name of this Object

      const std::string US_PROPKEY_PROBES_SELECTED;

      const std::string US_PROPKEY_BMODE_FREQUENCY;
      const std::string US_PROPKEY_BMODE_POWER;
      const std::string US_PROPKEY_BMODE_DEPTH;
      const std::string US_PROPKEY_BMODE_GAIN;
      const std::string US_PROPKEY_BMODE_REJECTION;
      const std::string US_PROPKEY_BMODE_DYNAMIC_RANGE;

      PropertyKeys()
        : US_INTERFACE_NAME("org.mitk.services.UltrasoundDevice"),
        US_PROPKEY_MANUFACTURER(US_INTERFACE_NAME + ".manufacturer"),
        US_PROPKEY_NAME(US_INTERFACE_NAME + ".name"),
        US_PROPKEY_COMMENT(US_INTERFACE_NAME + ".comment"),
        US_PROPKEY_LABEL(US_INTERFACE_NAME + ".label"),
        US_PROPKEY_ISCONNECTED(US_INTERFACE_NAME + ".isConnected"),
        US_PROPKEY_ISACTIVE(US_INTERFACE_NAME + ".isActive"),
        US_PROPKEY_CLASS(US_INTERFACE_NAME + ".class"),
        US_PROPKEY_PROBES_SELECTED(US_INTERFACE_NAME + ".probes.selected"),
        US_PROPKEY_BMODE_FREQUENCY(US_INTERFACE_NAME + ".bmode.frequency"),
        US_PROPKEY_BMODE_POWER(US_INTERFACE_NAME + ".bmode.power"),
        US_PROPKEY_BMODE_DEPTH(US_INTERFACE_NAME + ".bmode.depth"),
        US_PROPKEY_BMODE_GAIN(US_INTERFACE_NAME + ".bmode.gain"),
        US_PROPKEY_BMODE_REJECTION(US_INTERFACE_NAME + ".bmode.rejection"),
        US_PROPKEY_BMODE_DYNAMIC_RANGE(US_INTERFACE_NAME + ".bmode.dynamicRange")
      {}
    };

    mitkNewMessage2Macro(PropertyChanged, const std::string&, const std::string&)

      
       static mitk::USDevice::PropertyKeys GetPropertyKeys();

    virtual itk::SmartPointer<USAbstractControlInterface>   GetControlInterfaceCustom();

    virtual itk::SmartPointer<USControlInterfaceBMode>      GetControlInterfaceBMode();

    virtual itk::SmartPointer<USControlInterfaceProbes>     GetControlInterfaceProbes();

    virtual itk::SmartPointer<USControlInterfaceDoppler>    GetControlInterfaceDoppler();

    bool Initialize();

    bool Connect();

    void ConnectAsynchron();

    bool Disconnect();

    bool Activate();

    void Deactivate();

    virtual void SetIsFreezed(bool freeze);

    virtual bool GetIsFreezed();

    void PushFilter(AbstractOpenCVImageFilter::Pointer filter);
    void PushFilterIfNotPushedBefore(AbstractOpenCVImageFilter::Pointer filter);
    bool RemoveFilter(AbstractOpenCVImageFilter::Pointer filter);

    void ProbeChanged(std::string probename);

    void DepthChanged(double depth);

    void UpdateServiceProperty(std::string key, std::string value);
    void UpdateServiceProperty(std::string key, double value);
    void UpdateServiceProperty(std::string key, bool value);

    //########### GETTER & SETTER ##################//

    virtual std::string GetDeviceClass() = 0;

    bool GetIsInitialized();

    bool GetIsActive();

    bool GetIsConnected();

    /* @return Returns the area that will be cropped from the US image. Is disabled / [0,0,0,0] by default. */
    mitk::USDevice::USImageCropArea GetCropArea();

    virtual USImageSource::Pointer GetUSImageSource() = 0;

    DEPRECATED(std::string GetDeviceManufacturer());
    DEPRECATED(std::string GetDeviceModel());
    DEPRECATED(std::string GetDeviceComment());

    itkGetMacro(Manufacturer, std::string);
    itkGetMacro(Name, std::string);
    itkGetMacro(Comment, std::string);

    void SetManufacturer(std::string manufacturer);
    void SetName(std::string name);
    void SetComment(std::string comment);

    itkGetMacro(DeviceState, DeviceStates)
      itkGetMacro(ServiceProperties, us::ServiceProperties)

      void GrabImage();

  protected:
    itkSetMacro(Image, mitk::Image::Pointer);
    itkSetMacro(SpawnAcquireThread, bool);
    itkGetMacro(SpawnAcquireThread, bool);

    static ITK_THREAD_RETURN_TYPE Acquire(void* pInfoStruct);
    static ITK_THREAD_RETURN_TYPE ConnectThread(void* pInfoStruct);

    mitk::Image::Pointer m_Image;
    mitk::Image::Pointer m_OutputImage;

    void ProvideViaOIGTL();

    void DisableOIGTL();

    mitk::IGTLServer::Pointer m_IGTLServer;
    mitk::IGTLMessageProvider::Pointer m_IGTLMessageProvider;
    mitk::ImageToIGTLMessageFilter::Pointer m_ImageToIGTLMsgFilter;

    bool m_IsFreezed;

    DeviceStates m_DeviceState;

    /* @brief defines the area that should be cropped from the US image */
    USImageCropArea m_CropArea;

    us::ServiceProperties ConstructServiceProperties();

    void UnregisterOnService();

    virtual bool OnInitialization() = 0;

    virtual bool OnConnection() = 0;

    virtual bool OnDisconnection() = 0;

    virtual bool OnActivation() = 0;

    virtual bool OnDeactivation() = 0;

    virtual void OnFreeze(bool) { }

    USDevice(std::string manufacturer, std::string model);

    USDevice(mitk::USImageMetadata::Pointer metadata);

    virtual ~USDevice();

    virtual void GenerateData() override;

    std::string GetServicePropertyLabel();

  private:

    std::string m_Manufacturer;
    std::string m_Name;
    std::string m_Comment;

    bool m_SpawnAcquireThread;

    us::ServiceRegistration<Self> m_ServiceRegistration;

    us::ServiceProperties m_ServiceProperties;

    // Threading-Related
    itk::ConditionVariable::Pointer m_FreezeBarrier;
    itk::SimpleMutexLock        m_FreezeMutex;
    itk::MultiThreader::Pointer m_MultiThreader; 
    itk::FastMutexLock::Pointer m_ImageMutex; 
    int m_ThreadID; 

    bool m_UnregisteringStarted;
  };
} // namespace mitk

// This is the microservice declaration. Do not meddle!
MITK_DECLARE_SERVICE_INTERFACE(mitk::USDevice, "org.mitk.services.UltrasoundDevice")

#endif // MITKUSDevice_H_HEADER_INCLUDED_