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