mitkUSCombinedModality.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 MITKUSCombinedModality_H_HEADER_INCLUDED_
#define MITKUSCombinedModality_H_HEADER_INCLUDED_

#include <MitkUSNavigationExports.h>
#include "mitkUSDevice.h"
#include "mitkNavigationDataSource.h"

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

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

namespace mitk {
  class NavigationDataSmoothingFilter;
  class NavigationDataDelayFilter;
  class USControlInterfaceBMode;
  class USControlInterfaceProbes;
  class USControlInterfaceDoppler;

  class MITKUSNAVIGATION_EXPORT USCombinedModality : public USDevice
  {
  public:
    static const std::string DeviceClassIdentifier;
    static const char*       DefaultProbeIdentifier;
    static const char*       ProbeAndDepthSeperator;

    mitkClassMacro(USCombinedModality, USDevice);
    mitkNewMacro4Param(USCombinedModality, USDevice::Pointer, itk::SmartPointer<NavigationDataSource>, std::string, std::string);

    itkGetMacro(UltrasoundDevice, itk::SmartPointer<USDevice>);
    itkSetMacro(UltrasoundDevice, itk::SmartPointer<USDevice>);
    itkGetMacro(TrackingDevice, itk::SmartPointer<NavigationDataSource>);
    itkSetMacro(TrackingDevice, itk::SmartPointer<NavigationDataSource>);

    AffineTransform3D::Pointer GetCalibration();

    AffineTransform3D::Pointer GetCalibration(std::string depth);

    AffineTransform3D::Pointer GetCalibration(std::string depth, std::string probe);

    void SetCalibration(AffineTransform3D::Pointer calibration);

    bool RemoveCalibration();

    bool RemoveCalibration(std::string depth);

    bool RemoveCalibration(std::string depth, std::string probe);

    virtual std::string GetDeviceClass() override;

    virtual USImageSource::Pointer GetUSImageSource() override;

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

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

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

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

    virtual itk::SmartPointer<mitk::NavigationDataSource> GetNavigationDataSource();

    bool GetIsCalibratedForCurrentStatus();

    bool GetContainsAtLeastOneCalibration();

    void UnregisterOnService();

    std::string SerializeCalibration();

    void DeserializeCalibration(const std::string &xmlString, bool clearPreviousCalibrations = true);

    void SetNumberOfSmoothingValues(unsigned int numberOfSmoothingValues);

    void SetDelayCount(unsigned int delayCount);

    void RegisterAsMicroservice();

    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;
  protected:
    USCombinedModality(USDevice::Pointer usDevice, itk::SmartPointer<NavigationDataSource> trackingDevice, std::string manufacturer = "", std::string model = "");
    virtual ~USCombinedModality();

    virtual bool OnInitialization() override;

    virtual bool OnConnection() override;

    virtual bool OnDisconnection() override;

    virtual bool OnActivation() override;

    virtual bool OnDeactivation() override;

    virtual void OnFreeze(bool) override;

    void GenerateData() override;

    std::string GetIdentifierForCurrentCalibration();
    std::string GetIdentifierForCurrentProbe();
    std::string GetCurrentDepthValue();

    void RebuildFilterPipeline();

    USDevice::Pointer                                      m_UltrasoundDevice;
    itk::SmartPointer<NavigationDataSource>                m_TrackingDevice;
    std::map<std::string, AffineTransform3D::Pointer>      m_Calibrations;

    itk::SmartPointer<mitk::NavigationDataSmoothingFilter> m_SmoothingFilter;
    itk::SmartPointer<mitk::NavigationDataDelayFilter>     m_DelayFilter;
    itk::SmartPointer<mitk::NavigationDataSource>          m_LastFilter;

    unsigned int m_NumberOfSmoothingValues;
    unsigned int m_DelayCount;

  private:
    us::ServiceRegistration<Self>           m_ServiceRegistration;

    us::ServiceProperties                   m_ServiceProperties;
  };
} // namespace mitk

MITK_DECLARE_SERVICE_INTERFACE(mitk::USCombinedModality, "org.mitk.services.USCombinedModality")
#endif // MITKUSCombinedModality_H_HEADER_INCLUDED_