mitkAbstractUltrasoundTrackerDevice.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 mitkAbstractUltrasoundTrackerDevice_h
#define mitkAbstractUltrasoundTrackerDevice_h
 
#include <MitkUSNavigationExports.h>
#include "mitkUSDevice.h"
#include "mitkImageSource.h"
#include "mitkNavigationDataSource.h"
 
// Microservices
#include <mitkServiceInterface.h>
#include <usServiceRegistration.h>
#include <usGetModuleContext.h>
#include <usModule.h>
#include <usServiceProperties.h>
#include <usModuleContext.h>
 
namespace itk {
  template<class T> class SmartPointer;
}
 
namespace mitk {
  class NavigationDataSmoothingFilter;
  class NavigationDataDelayFilter;
  class NavigationDataDisplacementFilter;
 
  class MITKUSNAVIGATION_EXPORT AbstractUltrasoundTrackerDevice : public mitk::ImageSource
  {
  public:
 
    static const std::string DeviceClassIdentifier;
    static const char*       DefaultProbeIdentifier;
    static const char*       ProbeAndDepthSeperator;
    static const std::string US_INTERFACE_NAME;
    static const std::string US_PROPKEY_DEVICENAME;
    static const std::string US_PROPKEY_CLASS;
    static const std::string US_PROPKEY_ID;
 
 
    mitkClassMacro(AbstractUltrasoundTrackerDevice, mitk::ImageSource);
    mitkNewMacro3Param(AbstractUltrasoundTrackerDevice, USDevice::Pointer, itk::SmartPointer<NavigationDataSource>, bool);
 
    itkGetMacro(UltrasoundDevice, itk::SmartPointer<USDevice>);
    itkSetMacro(UltrasoundDevice, itk::SmartPointer<USDevice>);
    itkGetMacro(TrackingDeviceDataSource, itk::SmartPointer<NavigationDataSource>);
    itkSetMacro(TrackingDeviceDataSource, itk::SmartPointer<NavigationDataSource>);
 
    itkGetMacro(IsTrackedUltrasoundActive, bool);
 
    AffineTransform3D::Pointer GetCalibration();
 
    AffineTransform3D::Pointer GetCalibration(std::string depth);
 
    AffineTransform3D::Pointer GetCalibration(std::string depth, std::string probe);
 
    virtual AffineTransform3D::Pointer GetUSPlaneTransform();
 
    void SetCalibration(AffineTransform3D::Pointer calibration);
 
    bool RemoveCalibration();
 
    bool RemoveCalibration(std::string depth);
 
    bool RemoveCalibration(std::string depth, std::string probe);
 
    std::string GetDeviceClass();
 
    USImageSource::Pointer GetUSImageSource();
 
    itk::SmartPointer<mitk::NavigationDataSource> GetNavigationDataSource();
 
    bool GetIsCalibratedForCurrentStatus();
 
    bool GetContainsAtLeastOneCalibration();
 
    std::string SerializeCalibration();
 
    void DeserializeCalibration(const std::string &xmlString, bool clearPreviousCalibrations = true);
 
    void SetNumberOfSmoothingValues(unsigned int numberOfSmoothingValues);
 
    void SetDelayCount(unsigned int delayCount);
 
    void UnregisterOnService();
 
    virtual void RegisterAsMicroservice();
 
    virtual itk::SmartPointer<USAbstractControlInterface> GetControlInterfaceCustom();
 
    virtual itk::SmartPointer<USControlInterfaceBMode> GetControlInterfaceBMode();
 
    virtual itk::SmartPointer<USControlInterfaceProbes> GetControlInterfaceProbes();
 
    virtual itk::SmartPointer<USControlInterfaceDoppler> GetControlInterfaceDoppler();
 
    virtual void SetIsFreezed(bool freeze);
 
    virtual bool GetIsFreezed();
 
    virtual void OnFreeze(bool) { }
 
  protected:
    AbstractUltrasoundTrackerDevice( USDevice::Pointer usDevice,
                                     itk::SmartPointer<NavigationDataSource> trackingDevice,
                                     bool trackedUltrasoundActive );
    ~AbstractUltrasoundTrackerDevice() override;
 
 
    void GenerateData() override;
 
    std::string GetIdentifierForCurrentCalibration();
    std::string GetIdentifierForCurrentProbe();
    std::string GetCurrentDepthValue();
 
    void RebuildFilterPipeline();
 
    USDevice::Pointer                                      m_UltrasoundDevice;
    itk::SmartPointer<NavigationDataSource>                m_TrackingDeviceDataSource;
    std::map<std::string, AffineTransform3D::Pointer>      m_Calibrations;
 
    itk::SmartPointer<mitk::NavigationDataSmoothingFilter> m_SmoothingFilter;
    itk::SmartPointer<mitk::NavigationDataDelayFilter>     m_DelayFilter;
    itk::SmartPointer<mitk::NavigationDataDisplacementFilter> m_DisplacementFilter;
    itk::SmartPointer<mitk::NavigationDataSource> m_LastFilterOfIGTPipeline;
 
    unsigned int m_NumberOfSmoothingValues;
    unsigned int m_DelayCount;
 
    us::ServiceRegistration<Self>           m_ServiceRegistration;
 
    us::ServiceProperties                   m_ServiceProperties;
 
  private:
 
    bool m_IsFreezed;
    bool m_IsTrackedUltrasoundActive;
  };
 
} // namespace mitk
 
MITK_DECLARE_SERVICE_INTERFACE(mitk::AbstractUltrasoundTrackerDevice, "org.mitk.services.AbstractUltrasoundTrackerDevice")
 
#endif