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

// STL
#include <condition_variable>
#include <mutex>
#include <thread>
#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>

// 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);
    itkSetMacro(SpawnAcquireThread, bool);
    itkGetMacro(SpawnAcquireThread, bool);

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

    /* @return Returns the size of the m_ImageVector of the ultrasound device.*/
    unsigned int GetSizeOfImageVector();

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

    virtual std::vector<mitk::USProbe::Pointer> GetAllProbes() = 0;

    virtual void DeleteAllProbes() {};

    virtual mitk::USProbe::Pointer GetCurrentProbe() = 0;

    virtual void AddNewProbe(mitk::USProbe::Pointer /*probe*/) {};

    virtual mitk::USProbe::Pointer GetProbeByName(std::string name) = 0;

    virtual void RemoveProbeByName(std::string /*name*/) {};

    virtual void SetDefaultProbeAsCurrentProbe() {};

    virtual void SetCurrentProbe(std::string /*probename*/) {};

    virtual void SetSpacing(double xSpacing, double ySpacing);

  protected:

    // Threading-Related
    std::condition_variable m_FreezeBarrier;
    std::mutex m_FreezeMutex;
    std::mutex m_ImageMutex; 
    std::thread m_Thread;

    virtual void SetImageVector(std::vector<mitk::Image::Pointer> vec)
    {
      if (this->m_ImageVector != vec)
      {
      this->m_ImageVector = vec;
      this->Modified();
      }
    }

    void Acquire();
    void ConnectThread();

    std::vector<mitk::Image::Pointer> m_ImageVector;

    // Variables to determine if spacing was calibrated and needs to be applied to the incoming images
    mitk::Vector3D m_Spacing;

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

    ~USDevice() override;

    void GenerateData() override;

    std::string GetServicePropertyLabel();

    unsigned int m_NumberOfOutputs;

    us::ServiceProperties m_ServiceProperties;

    us::ServiceRegistration<Self> m_ServiceRegistration;


  private:

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

    bool m_SpawnAcquireThread;

    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_