cxToolMetricWrapper.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 "cxToolMetricWrapper.h"
#include <QHBoxLayout>
#include "cxSpaceEditWidget.h"
#include "cxHelperWidgets.h"
#include "cxTrackingService.h"
#include "cxSpaceProvider.h"
#include "cxPatientModelService.h"
#include "cxVisServices.h"
 
namespace cx {
 
ToolMetricWrapper::ToolMetricWrapper(VisServicesPtr services, cx::ToolMetricPtr data) :
        MetricBase(services),
        mData(data)
{
        mInternalUpdate = false;
//      connect(mData.get(), SIGNAL(transformChanged()), this, SLOT(dataChangedSlot()));
//      connect(mData.get(), SIGNAL(propertiesChanged()), this, SLOT(dataChangedSlot()));
//      connect(mPatientModelService.get(), SIGNAL(dataAddedOrRemoved()), this, SLOT(dataChangedSlot()));
}
 
ToolMetricWrapper::~ToolMetricWrapper()
{
//      disconnect(mPatientModelService.get(), SIGNAL(dataAddedOrRemoved()), this, SLOT(dataChangedSlot()));
}
 
QWidget* ToolMetricWrapper::createWidget()
{
        this->initializeProperties();
 
        QWidget* widget = this->newWidget("tool_metric");
 
        QVBoxLayout* topLayout = new QVBoxLayout(widget);
        topLayout->setMargin(0);
 
        QHBoxLayout* hLayout2 = new QHBoxLayout;
        hLayout2->setMargin(0);
        topLayout->addLayout(hLayout2);
 
        QHBoxLayout* hLayout = new QHBoxLayout;
        hLayout->setMargin(0);
        topLayout->addLayout(hLayout);
 
        hLayout2->addWidget(createDataWidget(mServices->view(), mServices->patient(), widget, mToolNameSelector));
        hLayout2->addWidget(createDataWidget(mServices->view(), mServices->patient(), widget, mToolOffsetSelector));
 
        hLayout->addWidget(new SpaceEditWidget(widget, mSpaceSelector));
 
        QPushButton* sampleButton = new QPushButton("Sample");
        connect(sampleButton, SIGNAL(clicked()), this, SLOT(resampleMetric()));
        sampleButton->setToolTip("Set the position equal to the current tool tip position.");
        hLayout->addWidget(sampleButton);
 
        mFrameWidget = new Transform3DWidget(widget);
        connect(mFrameWidget, SIGNAL(changed()), this, SLOT(frameWidgetChangedSlot()));
        topLayout->addWidget(mFrameWidget);
 
        this->addColorWidget(topLayout);
 
//      this->dataChangedSlot();
 
        return widget;
}
 
void ToolMetricWrapper::initializeProperties()
{
        mSpaceSelector = SpaceProperty::initialize("selectSpace",
                                                                                          "Space",
                                                                                          "Select coordinate system to store position in.");
 
        mSpaceSelector->setSpaceProvider(mServices->spaceProvider());
        connect(mSpaceSelector.get(), SIGNAL(valueWasSet()), this, SLOT(spaceSelected()));
 
        mToolNameSelector = StringProperty::initialize("selectToolName",
                                                                                                                          "Tool Name",
                                                                                                                          "The name of the tool",
                                                                                                                          "",
                                                                                                                          QDomNode());
        connect(mToolNameSelector.get(), SIGNAL(valueWasSet()), this, SLOT(toolNameSet()));
 
        mToolOffsetSelector = DoubleProperty::initialize("selectToolOffset",
                                                                                                                                "Tool Offset",
                                                                                                                                "Tool Offset",
                                                                                                                                0,
                                                                                                                                DoubleRange(0, 100, 1),
                                                                                                                                1);
        connect(mToolOffsetSelector.get(), SIGNAL(valueWasSet()), this, SLOT(toolOffsetSet()));
}
 
QString ToolMetricWrapper::getValue() const
{
        return prettyFormat(mData->getRefCoord(), 1, 3);
}
 
DataMetricPtr ToolMetricWrapper::getData() const
{
        return mData;
}
 
QString ToolMetricWrapper::getType() const
{
        return "tool";
}
 
QString ToolMetricWrapper::getArguments() const
{
        return mData->getSpace().toString();
}
 
 
void ToolMetricWrapper::resampleMetric()
{
//      CoordinateSystem ref = CoordinateSystemHelpers::getR();
        Transform3D qMt = mServices->spaceProvider()->getActiveToolTipTransform(mData->getSpace(), true);
        mData->setFrame(qMt);
        mData->setToolName(mServices->tracking()->getActiveTool()->getName());
        mData->setToolOffset(mServices->tracking()->getActiveTool()->getTooltipOffset());
}
 
 
void ToolMetricWrapper::spaceSelected()
{
        if (mInternalUpdate)
                return;
        CoordinateSystem space = mSpaceSelector->getValue();
        if (space.isValid())
                mData->setSpace(space);
}
 
void ToolMetricWrapper::toolNameSet()
{
        if (mInternalUpdate)
                return;
        mData->setToolName(mToolNameSelector->getValue());
}
 
void ToolMetricWrapper::toolOffsetSet()
{
        if (mInternalUpdate)
                return;
        mData->setToolOffset(mToolOffsetSelector->getValue());
}
 
//void ToolMetricWrapper::dataChangedSlot()
//{
//}
 
void ToolMetricWrapper::update()
{
        mInternalUpdate = true;
 
        mSpaceSelector->setValue(mData->getSpace());
        mFrameWidget->setMatrix(mData->getFrame());
        mToolNameSelector->setValue(mData->getToolName());
        mToolOffsetSelector->setValue(mData->getToolOffset());
 
        mInternalUpdate = false;
}
 
 
void ToolMetricWrapper::frameWidgetChangedSlot()
{
        if (mInternalUpdate)
                return;
        Transform3D matrix = mFrameWidget->getMatrix();
        mData->setFrame(matrix);
}
 
 
} //namespace cx