cxToolProxy.cpp

Go to the documentation of this file.

#include "cxToolProxy.h"
#include "boost/bind.hpp"
#include "cxNullDeleter.h"
#include "cxTrackingService.h"
#include "cxTypeConversions.h"

namespace cx
{

ToolPtr ToolProxy::create(ToolPtr base, ctkPluginContext *pluginContext)
{
        return boost::shared_ptr<ToolProxy>(new ToolProxy(base, pluginContext));
}

ToolProxy::ToolProxy(ToolPtr base, ctkPluginContext *pluginContext)
{
        mTool = base;
        mPluginContext = pluginContext;
        this->initServiceListener();
}

void ToolProxy::initServiceListener()
{
        mServiceListener.reset(new ServiceTrackerListener<TrackingService>(
                                                           mPluginContext,
                                                           boost::bind(&ToolProxy::onServiceAdded, this, _1),
                                                           boost::function<void (TrackingService*)>(),
                                                           boost::bind(&ToolProxy::onServiceRemoved, this, _1)
                                                           ));
        mServiceListener->open();
}

void ToolProxy::onServiceAdded(TrackingService* service)
{
        mTrackingService.reset(service, null_deleter());

        connect(mTrackingService.get(), &TrackingService::stateChanged, this, &ToolProxy::onStateChanged);

        this->checkToolValidity();
}

void ToolProxy::onServiceRemoved(TrackingService *service)
{
        mTrackingService = TrackingService::getNullObject();
        mTool = Tool::getNullObject();
        // emit changed signals
}

void ToolProxy::onStateChanged()
{
        this->checkToolValidity();
}

void ToolProxy::checkToolValidity()
{
        if (mTool != mTrackingService->getTool(mTool->getUid()))
        {
                std::cout << "disabling tool reference for " << mTool->getUid() << ", [currently disabled]" << std::endl;
                // enable this when tool manager is a first-class plugin
                //              mTool = Tool::getNullObject();
                // emit changed signals
        }
}

std::set<Tool::Type> ToolProxy::getTypes() const
{
        return mTool->getTypes();
}

vtkPolyDataPtr ToolProxy::getGraphicsPolyData() const
{
        return mTool->getGraphicsPolyData();
}

TimedTransformMapPtr ToolProxy::getPositionHistory()
{
        return mTool->getPositionHistory();
}

ToolPositionMetadata ToolProxy::getMetadata() const
{
        return mTool->getMetadata();
}

const std::map<double, ToolPositionMetadata>& ToolProxy::getMetadataHistory()
{
        return mTool->getMetadataHistory();
}

bool ToolProxy::getVisible() const
{
        return mTool->getVisible();
}

bool ToolProxy::isInitialized() const
{
        return mTool->isInitialized();
}

QString ToolProxy::getUid() const
{
        return mTool->getUid();
}


QString ToolProxy::getName() const
{
        return mTool->getName();
}

bool ToolProxy::isCalibrated() const
{
        return mTool->isCalibrated();
}
Transform3D ToolProxy::getCalibration_sMt() const
{
        return mTool->getCalibration_sMt();
}

void ToolProxy::setCalibration_sMt(Transform3D calibration)
{
        mTool->setCalibration_sMt(calibration);
}

ProbePtr ToolProxy::getProbe() const
{
        return mTool->getProbe();
}

double ToolProxy::getTimestamp() const
{
        return mTool->getTimestamp();
}

void ToolProxy::printSelf(std::ostream &os, Indent indent)
{
        mTool->printSelf(os, indent);
}

double ToolProxy::getTooltipOffset() const
{
        return mTool->getTooltipOffset();
}

void ToolProxy::setTooltipOffset(double val)
{
        mTool->setTooltipOffset(val);
}

std::map<QString, Vector3D> ToolProxy::getReferencePoints() const
{
        return mTool->getReferencePoints();
}

bool ToolProxy::hasReferencePointWithId(QString id)
{
        return mTool->hasReferencePointWithId(id);
}

TimedTransformMap ToolProxy::getSessionHistory(double startTime, double stopTime)
{
        return mTool->getSessionHistory(startTime, stopTime);
}

Transform3D ToolProxy::get_prMt() const
{
        return mTool->get_prMt();
}

void ToolProxy::resetTrackingPositionFilter(TrackingPositionFilterPtr filter)
{
        mTool->resetTrackingPositionFilter(filter);
}

void ToolProxy::set_prMt(const Transform3D& prMt, double timestamp)
{
        mTool->set_prMt(prMt, timestamp);
}

void ToolProxy::setVisible(bool vis)
{
        mTool->setVisible(vis);
}

ToolPtr ToolProxy::getBaseTool()
{
        return mTool->getBaseTool();
}


bool ToolProxy::isNull()
{
        return mTool->isNull();
}

} // namespace cx