cxUsReconstructionServiceProxy.cpp

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.
=========================================================================*/

#include "cxUsReconstructionServiceProxy.h"

#include <boost/bind.hpp>
//#include <QString.h>

//#include "cxUSReconstructInputData.h"
#include "cxLogger.h"

//#include <set>
//#include "cxForwardDeclarations.h"
//#include "cxXmlOptionItem.h"
//#include "cxReconstructCore.h"
#include "cxUSReconstructInputData.h"
//#include "cxReconstructedOutputVolumeParams.h"
//#include "cxReconstructionMethodService.h"
//#include "cxServiceTrackerListener.h"

#include "cxNullDeleter.h"

namespace cx {

UsReconstructionServiceProxy::UsReconstructionServiceProxy(ctkPluginContext *pluginContext) :
        mPluginContext(pluginContext),
        mUsReconstructionService(UsReconstructionService::getNullObject())
{
        this->initServiceListener();
}


void UsReconstructionServiceProxy::initServiceListener()
{
        mServiceListener.reset(new ServiceTrackerListener<UsReconstructionService>(
                                                                 mPluginContext,
                                                                 boost::bind(&UsReconstructionServiceProxy::onServiceAdded, this, _1),
                                                                 boost::function<void (UsReconstructionService*)>(),
                                                                 boost::bind(&UsReconstructionServiceProxy::onServiceRemoved, this, _1)
                                                                 ));
        mServiceListener->open();
}
void UsReconstructionServiceProxy::onServiceAdded(UsReconstructionService* service)
{
        mUsReconstructionService.reset(service, null_deleter());
        connect(service, &UsReconstructionService::paramsChanged, this, &UsReconstructionService::paramsChanged);
        connect(service, &UsReconstructionService::algorithmChanged, this, &UsReconstructionService::algorithmChanged);
        connect(service, &UsReconstructionService::inputDataSelected, this, &UsReconstructionService::inputDataSelected);
        connect(service, &UsReconstructionService::reconstructAboutToStart, this, &UsReconstructionService::reconstructAboutToStart);
        connect(service, &UsReconstructionService::reconstructStarted, this, &UsReconstructionService::reconstructStarted);
        connect(service, &UsReconstructionService::reconstructFinished, this, &UsReconstructionService::reconstructFinished);
        connect(service, &UsReconstructionService::newInputDataAvailable, this, &UsReconstructionService::newInputDataAvailable);
        connect(service, &UsReconstructionService::newInputDataPath, this, &UsReconstructionService::newInputDataAvailable);

        if(mUsReconstructionService->isNull())
                reportWarning("UsReconstructionServiceProxy::onServiceAdded mVideoService->isNull()");

        emit paramsChanged();
        emit algorithmChanged();
}

void UsReconstructionServiceProxy::onServiceRemoved(UsReconstructionService *service)
{
        disconnect(service, &UsReconstructionService::paramsChanged, this, &UsReconstructionService::paramsChanged);
        disconnect(service, &UsReconstructionService::algorithmChanged, this, &UsReconstructionService::algorithmChanged);
        disconnect(service, &UsReconstructionService::inputDataSelected, this, &UsReconstructionService::inputDataSelected);
        disconnect(service, &UsReconstructionService::reconstructAboutToStart, this, &UsReconstructionService::reconstructAboutToStart);
        disconnect(service, &UsReconstructionService::reconstructStarted, this, &UsReconstructionService::reconstructStarted);
        disconnect(service, &UsReconstructionService::reconstructFinished, this, &UsReconstructionService::reconstructFinished);
        disconnect(service, &UsReconstructionService::newInputDataAvailable, this, &UsReconstructionService::newInputDataAvailable);
        disconnect(service, &UsReconstructionService::newInputDataPath, this, &UsReconstructionService::newInputDataAvailable);
        mUsReconstructionService = UsReconstructionService::getNullObject();

        emit paramsChanged();
        emit algorithmChanged();
}

bool UsReconstructionServiceProxy::isNull()
{
        return mUsReconstructionService->isNull();
}



void UsReconstructionServiceProxy::selectData(QString filename, QString calFilesPath)
{
        mUsReconstructionService->selectData(filename, calFilesPath);
}

void UsReconstructionServiceProxy::selectData(USReconstructInputData data)
{
        mUsReconstructionService->selectData(data);
}

QString UsReconstructionServiceProxy::getSelectedFilename() const
{
        return mUsReconstructionService->getSelectedFilename();
}

USReconstructInputData UsReconstructionServiceProxy::getSelectedFileData()
{
        return mUsReconstructionService->getSelectedFileData();
}

PropertyPtr UsReconstructionServiceProxy::getParam(QString uid)
{
        return mUsReconstructionService->getParam(uid);
}

//ReconstructParamsPtr UsReconstructionServiceProxy::getParams()
//{
//      return mUsReconstructionService->getParams();
//}

std::vector<PropertyPtr> UsReconstructionServiceProxy::getAlgoOptions()
{
        return mUsReconstructionService->getAlgoOptions();
}

XmlOptionFile UsReconstructionServiceProxy::getSettings()
{
        return mUsReconstructionService->getSettings();
}

OutputVolumeParams UsReconstructionServiceProxy::getOutputVolumeParams() const
{
        return mUsReconstructionService->getOutputVolumeParams();
}

void UsReconstructionServiceProxy::setOutputVolumeParams(const OutputVolumeParams &par)
{
        mUsReconstructionService->setOutputVolumeParams(par);
}

//void UsReconstructionServiceProxy::setOutputRelativePath(QString path)
//{
//      mUsReconstructionService->setOutputRelativePath(path);
//}

//void UsReconstructionServiceProxy::setOutputBasePath(QString path)
//{
//      mUsReconstructionService->setOutputBasePath(path);
//}

void UsReconstructionServiceProxy::startReconstruction()
{
        mUsReconstructionService->startReconstruction();
}

std::set<TimedAlgorithmPtr> UsReconstructionServiceProxy::getThreadedReconstruction()
{
        return mUsReconstructionService->getThreadedReconstruction();
}

ReconstructionMethodService* UsReconstructionServiceProxy::createAlgorithm()
{
        return mUsReconstructionService->createAlgorithm();
}

ReconstructCore::InputParams UsReconstructionServiceProxy::createCoreParameters()
{
        return mUsReconstructionService->createCoreParameters();
}

void UsReconstructionServiceProxy::newDataOnDisk(QString mhdFilename)
{
        return mUsReconstructionService->newDataOnDisk(mhdFilename);
}

} //cx