mitkNDITrackingDevice.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 MITKNDITRACKINGDEVICE_H_HEADER_INCLUDED_C1C2FCD2
#define MITKNDITRACKINGDEVICE_H_HEADER_INCLUDED_C1C2FCD2

#include "mitkTrackingDevice.h"

#include <MitkIGTExports.h>
#include <itkMultiThreader.h>
#include "itkFastMutexLock.h"
#include <vector>

#include "mitkNDIProtocol.h"
#include "mitkNDIPassiveTool.h"
#include "mitkSerialCommunication.h"


namespace mitk
{
  class NDIProtocol;

  class MITKIGT_EXPORT NDITrackingDevice : public TrackingDevice
  {
    friend class NDIProtocol;

  public:
    typedef std::vector<NDIPassiveTool::Pointer> Tool6DContainerType;  

    typedef mitk::TrackingDeviceType NDITrackingDeviceType;  
    typedef mitk::SerialCommunication::PortNumber PortNumber; 
    typedef mitk::SerialCommunication::BaudRate BaudRate;     
    typedef mitk::SerialCommunication::DataBits DataBits;     
    typedef mitk::SerialCommunication::Parity Parity;         
    typedef mitk::SerialCommunication::StopBits StopBits;     
    typedef mitk::SerialCommunication::HardwareHandshake HardwareHandshake; 
    typedef mitk::NDIPassiveTool::TrackingPriority TrackingPriority; 

    mitkClassMacro(NDITrackingDevice, TrackingDevice);
    itkFactorylessNewMacro(Self);
    itkCloneMacro(Self);

    //itkSetMacro(Type, TrackingDeviceType);


    bool OpenConnection() override;

    bool CloseConnection() override;

    bool InitializeWiredTools();

    void SetRotationMode(RotationMode r) override;

    virtual mitk::TrackingDeviceType TestConnection();

    bool DiscoverWiredTools();

    bool StartTracking() override;

    TrackingTool* GetTool(unsigned int toolNumber) const override;

    mitk::TrackingTool* GetToolByName(std::string name) const override;
    unsigned int GetToolCount() const override;

    mitk::TrackingTool* AddTool(const char* toolName, const char* fileName, TrackingPriority p = NDIPassiveTool::Dynamic);

    virtual bool RemoveTool(TrackingTool* tool);

    virtual bool UpdateTool(mitk::TrackingTool* tool);

    virtual void SetPortNumber(const PortNumber _arg); 
    itkGetConstMacro(PortNumber, PortNumber);          
    virtual void SetDeviceName(std::string _arg);      
    itkGetStringMacro(DeviceName);                     
    virtual void SetBaudRate(const BaudRate _arg);     
    itkGetConstMacro(BaudRate, BaudRate);              
    virtual void SetDataBits(const DataBits _arg);     
    itkGetConstMacro(DataBits, DataBits);              
    virtual void SetParity(const Parity _arg);         
    itkGetConstMacro(Parity, Parity);                  
    virtual void SetStopBits(const StopBits _arg);     
    itkGetConstMacro(StopBits, StopBits);              
    virtual void SetHardwareHandshake(const HardwareHandshake _arg);  
    itkGetConstMacro(HardwareHandshake, HardwareHandshake);              
    virtual void SetIlluminationActivationRate(const IlluminationActivationRate _arg); 
    itkGetConstMacro(IlluminationActivationRate, IlluminationActivationRate);          
    virtual void SetDataTransferMode(const DataTransferMode _arg);    
    itkGetConstMacro(DataTransferMode, DataTransferMode);              
    virtual bool Beep(unsigned char count);   

    NDIErrorCode GetErrorCode(const std::string* input);  

    virtual bool SetOperationMode(OperationMode mode);  
    virtual OperationMode GetOperationMode();           

    virtual bool GetMarkerPositions(MarkerPointContainerType* markerpositions);

    virtual int GetMajorFirmwareRevisionNumber();

    virtual const char* GetFirmwareRevisionNumber();

    bool AutoDetectToolsAvailable() override;

    bool AddSingleToolIsAvailable() override;

    mitk::NavigationToolStorage::Pointer AutoDetectTools() override;



  protected:

    typedef std::vector<std::string> NDITrackingVolumeContainerType;  
    typedef std::vector<int> TrackingVolumeDimensionType;          

    virtual bool GetSupportedVolumes(unsigned int* numberOfVolumes, NDITrackingVolumeContainerType* volumes, TrackingVolumeDimensionType* volumesDimensions);

    virtual bool SetVolume(mitk::TrackingDeviceData volume);

    virtual bool InternalAddTool(NDIPassiveTool* tool);

    /* Methods for NDIProtocol friend class */
    virtual void InvalidateAll();             
    NDIPassiveTool* GetInternalTool(std::string portHandle); 

    NDIErrorCode FreePortHandles();

    NDIErrorCode Send(const std::string* message, bool addCRC = true);      
    NDIErrorCode Receive(std::string* answer, unsigned int numberOfBytes);  
    NDIErrorCode ReceiveByte(char* answer);   
    NDIErrorCode ReceiveLine(std::string* answer); 
    void ClearSendBuffer();                   
    void ClearReceiveBuffer();                
    const std::string CalcCRC(const std::string* input);  

public:

    virtual void TrackTools();

    virtual void TrackMarkerPositions();

    virtual void TrackToolsAndMarkers();

    static ITK_THREAD_RETURN_TYPE ThreadStartTracking(void* data);

  protected:
    NDITrackingDevice();          
    ~NDITrackingDevice() override; 

    std::string m_DeviceName;
    PortNumber m_PortNumber; 
    BaudRate m_BaudRate;     
    DataBits m_DataBits;     
    Parity m_Parity;         
    StopBits m_StopBits;     
    HardwareHandshake m_HardwareHandshake; 
    IlluminationActivationRate m_IlluminationActivationRate; 
    DataTransferMode m_DataTransferMode;  
    Tool6DContainerType m_6DTools;        

    itk::FastMutexLock::Pointer m_ToolsMutex; 
    mitk::SerialCommunication::Pointer m_SerialCommunication;    
    itk::FastMutexLock::Pointer m_SerialCommunicationMutex; 
    NDIProtocol::Pointer m_DeviceProtocol;    

    itk::MultiThreader::Pointer m_MultiThreader;      
    int m_ThreadID;                 
    OperationMode m_OperationMode;  
    itk::FastMutexLock::Pointer m_MarkerPointsMutex;  
    MarkerPointContainerType m_MarkerPoints;          
  };
} // namespace mitk
#endif /* MITKNDITRACKINGDEVICE_H_HEADER_INCLUDED_C1C2FCD2 */