cxTrackingImplService.h

Go to the documentation of this file.

/*=========================================================================
This file is part of CustusX, an Image Guided Therapy Application.
                 
Copyright (c) SINTEF Department of Medical Technology.
All rights reserved.
                 
CustusX is released under a BSD 3-Clause license.
                 
See Lisence.txt (https://github.com/SINTEFMedtek/CustusX/blob/master/License.txt) for details.
=========================================================================*/

#ifndef CXTRACKINGIMPLSERVICE_H_
#define CXTRACKINGIMPLSERVICE_H_

#include "org_custusx_core_tracking_Export.h"
#include "cxTrackingService.h"
#include "vtkForwardDeclarations.h"
#include "cxServiceTrackerListener.h"

class QDomNode;
class QDomElement;
class QDomDocument;
class QDomNodeList;
class QTimer;
class QFileInfo;

class ctkPluginContext;

namespace cx
{
typedef boost::shared_ptr<class TrackingImplService> TrackingImplServicePtr;

typedef boost::shared_ptr<class ManualToolAdapter> ManualToolAdapterPtr;
typedef boost::shared_ptr<class PlaybackTime> PlaybackTimePtr;

typedef boost::shared_ptr<class TrackingSystemService> TrackingSystemServicePtr;
typedef boost::shared_ptr<class TrackingSystemPlaybackService> TrackingSystemPlaybackServicePtr;
typedef boost::shared_ptr<class SessionStorageService> SessionStorageServicePtr;

class org_custusx_core_tracking_EXPORT TrackingImplService: public TrackingService
{
Q_OBJECT
Q_INTERFACES(cx::TrackingService)

public:
        TrackingImplService(ctkPluginContext* context);
        virtual ~TrackingImplService();

        virtual Tool::State getState() const;
        virtual void setState(const Tool::State val);

        virtual bool isPlaybackMode() const;

        virtual ToolMap getTools(); 
        virtual ToolPtr getTool(const QString& uid); 

        virtual ToolPtr getActiveTool();
        virtual void setActiveTool(const QString& uid); 
        virtual void clearActiveTool();

        virtual ToolPtr getReferenceTool() const; 

        virtual ToolPtr getManualTool(); 

        virtual SessionToolHistoryMap getSessionHistory(double startTime, double stopTime);

        virtual void runDummyTool(DummyToolPtr tool);
        virtual ToolPtr getFirstProbe();

        virtual void setPlaybackMode(PlaybackTimePtr controller);
        virtual std::vector<TrackerConfigurationPtr> getConfigurations();
        //virtual TrackerConfigurationPtr getConfiguration(QString trackingSystemImplementation);
        virtual TrackerConfigurationPtr getConfiguration();
        virtual QString getCurrentTrackingSystemImplementation();

        virtual void installTrackingSystem(TrackingSystemServicePtr system);
        virtual void unInstallTrackingSystem(TrackingSystemServicePtr system);
        virtual std::vector<TrackingSystemServicePtr> getTrackingSystems();
        virtual void resetTimeSynchronization();

        bool isNull();
        virtual void setCurrentTrackingSystemImplementation(QString trackingSystemImplementation);

public slots:

private slots:
        void globalConfigurationFileChangedSlot(QString key);
        void onSystemStateChanged();
        void activeCheckSlot(); 
        void onTooltipOffset(double val);

        void onSessionChanged();
        void onSessionCleared();
        void onSessionLoad(QDomElement& node);
        void onSessionSave(QDomElement& node);

private:
        void listenForTrackingSystemServices(ctkPluginContext *context);
        void onTrackingSystemAdded(TrackingSystemService* service);
        void onTrackingSystemRemoved(TrackingSystemService* service);
        void onTrackingSystemModified(TrackingSystemService* service);


        void rebuildCachedTools();
        void initializeManualTool();
        void setConfigurationFile(QString configurationFile); 
        void resetTrackingPositionFilters();
        void waitForState(Tool::State state, int timeout);
        void imbueManualToolWithRealProperties();
        void addToolsFrom(TrackingSystemServicePtr system);
        bool manualToolHasMostRecentTimestamp();
        std::vector<ToolPtr> getVisibleTools();

        void addXml(QDomNode& parentNode); 
        void parseXml(QDomNode& dataNode); 
        virtual void savePositionHistory();
        virtual void loadPositionHistory();

        QString getLoggingFolder();
        virtual TrackerConfigurationPtr getConfiguration(QString trackingSystemImplementation);

        ToolMap mTools; 
        ToolPtr mActiveTool; 
        ToolPtr mReferenceTool; 
        ManualToolAdapterPtr mManualTool; 

        double mLastLoadPositionHistory;

        std::vector<TrackingSystemServicePtr> mTrackingSystems;
        TrackingSystemPlaybackServicePtr mPlaybackSystem;
        ctkPluginContext *mContext;
        SessionStorageServicePtr mSession;

        double mToolTipOffset; 

        boost::shared_ptr<ServiceTrackerListener<TrackingSystemService> > mServiceListener;
        QString mTrackingSystemImplementation;
};

bool toolTypeSort(const ToolPtr tool1, const ToolPtr tool2); 

} //namespace cx


#endif /* CXTRACKINGIMPLSERVICE_H_ */