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
#define mitkUSDevice_h
 
// 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