cxDataMetricWrappers.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 <cxDataMetricWrappers.h>

#include <QTreeWidget>
#include <QTreeWidgetItem>
#include <QStringList>
#include <QVBoxLayout>
#include <QHeaderView>

#include "cxLogger.h"
#include "cxTypeConversions.h"
#include "cxCoordinateSystemHelpers.h"
#include "cxTrackingService.h"
#include "cxPointMetric.h"
#include "cxDistanceMetric.h"
#include "cxLabeledComboBoxWidget.h"
#include "cxVector3DWidget.h"
#include "cxRegistrationTransform.h"
#include "cxHelperWidgets.h"
#include "cxBaseWidget.h"
#include "cxBoolProperty.h"
#include "cxSpaceProvider.h"
#include "cxPatientModelService.h"
#include "cxSpaceEditWidget.h"
#include "cxSpaceProperty.h"
#include "cxStringListProperty.h"
#include "cxStringListSelectWidget.h"
#include "cxVisServices.h"

namespace cx
{

MetricBase::MetricBase(VisServicesPtr services) :
        mServices(services)
{
}

void MetricBase::colorSelected()
{
        this->getData()->setColor(mColorSelector->getValue());
}

QString MetricBase::getValue() const
{
        QString retval = this->getData()->getValueAsString();
        if (retval.isEmpty())
                return "NA";
        return retval;
}

void MetricBase::addColorWidget(QVBoxLayout* layout)
{
        mColorSelector = ColorProperty::initialize("color", "Color",
                                                                                                         "Set color of metric",
                                                                                                         this->getData()->getColor(), QDomNode());
        QHBoxLayout* line = new QHBoxLayout;
        line->addWidget(createDataWidget(mServices->view(), mServices->patient(), NULL, mColorSelector));
        line->addStretch();
        line->setMargin(0);
        layout->addLayout(line);
        connect(mColorSelector.get(), SIGNAL(valueWasSet()), this, SLOT(colorSelected()));
}

QWidget *cx::MetricBase::newWidget(QString objectName)
{
        QWidget* widget = new QWidget;
        widget->setFocusPolicy(Qt::StrongFocus); // needed for help system: focus is used to display help text
        widget->setObjectName(objectName);
        return widget;
}
//---------------------------------------------------------
//---------------------------------------------------------
//---------------------------------------------------------

MetricReferenceArgumentListGui::MetricReferenceArgumentListGui(VisServicesPtr services) :
        mServices(services)
{
        mModified = true;
        mInternalUpdate = false;
}

void MetricReferenceArgumentListGui::setArguments(MetricReferenceArgumentListPtr arguments)
{
        mArguments = arguments;
        connect(mArguments.get(), SIGNAL(argumentsChanged()), this, SLOT(dataChangedSlot()));
}

void MetricReferenceArgumentListGui::addWidgets(QBoxLayout* layout)
{
        QString value;

        mPSelector.resize(mArguments->getCount());
        for (unsigned i=0; i<mPSelector.size(); ++i)
        {
                mPSelector[i] = StringProperty::initialize(QString("p%1").arg(i),
                                                                                                                 QString("p%1").arg(i),
                                                                                                                 mArguments->getDescription(i),
                                                                                                                 mArguments->get(i) ? mArguments->get(i)->getUid() : "",
                                                                                                                 QStringList(),
                                                                                                                 QDomNode());
//              mPSelector[i]->setDisplayNames(names);
                layout->addWidget(new LabeledComboBoxWidget(NULL, mPSelector[i]));
                connect(mPSelector[i].get(), SIGNAL(valueWasSet()), this, SLOT(pointSelected()));
        }

        this->dataChangedSlot();
}

void MetricReferenceArgumentListGui::getAvailableArgumentMetrics(QStringList* uid, std::map<QString,QString>* namemap)
{
        std::map<QString, DataPtr> data = mServices->patient()->getDatas();
        for (std::map<QString, DataPtr>::iterator iter=data.begin(); iter!=data.end(); ++iter)
        {
                if (mArguments->validArgument(iter->second))
                {
                        *uid << iter->first;
                        (*namemap)[iter->first] = iter->second->getName();
                }
        }
}

QString MetricReferenceArgumentListGui::getAsString() const
{
        QStringList data;
        for (unsigned i=0; i<mArguments->getCount(); ++i)
                data << (mArguments->get(i) ? mArguments->get(i)->getName() : QString("*"));
        return data.join("-");
}

void MetricReferenceArgumentListGui::pointSelected()
{
        if (mInternalUpdate)
                return;
        for (unsigned i=0; i<mPSelector.size(); ++i)
        {
                DataPtr data = mServices->patient()->getData(mPSelector[i]->getValue());
                if (mArguments->validArgument(data))
                        mArguments->set(i, data);
                else
                        reportWarning(QString("Failed to set data [%1] in metric, invalid argument.").arg(data?data->getName():"NULL"));
        }
}

void MetricReferenceArgumentListGui::dataChangedSlot()
{
//      mModified = true;
}

void MetricReferenceArgumentListGui::update()
{
        if (!mModified)
                return;
        mInternalUpdate = true;

        QStringList range;
        std::map<QString,QString> names;
        this->getAvailableArgumentMetrics(&range, &names);

        for (unsigned i=0; i<mPSelector.size(); ++i)
        {
                if (!mArguments->get(i))
                        continue;
                mPSelector[i]->setValue(mArguments->get(i)->getUid());
                mPSelector[i]->setDisplayNames(names);
                mPSelector[i]->setValueRange(range);
        }

        mInternalUpdate = false;
        mModified = true;
}


//---------------------------------------------------------
//---------------------------------------------------------
//---------------------------------------------------------

PointMetricWrapper::PointMetricWrapper(VisServicesPtr services, PointMetricPtr data) :
        MetricBase(services),
        mData(data)
{
        mInternalUpdate = false;
//      connect(mData.get(), SIGNAL(transformChanged()), this, SLOT(dataChangedSlot()));
//      connect(mPatientModelService.get(), SIGNAL(dataAddedOrRemoved()), this, SLOT(dataChangedSlot()));
}

PointMetricWrapper::~PointMetricWrapper()
{
//      disconnect(mPatientModelService.get(), SIGNAL(dataAddedOrRemoved()), this, SLOT(dataChangedSlot()));
}

QWidget* PointMetricWrapper::createWidget()
{
        QWidget* widget = this->newWidget("point_metric");
        QVBoxLayout* topLayout = new QVBoxLayout(widget);
        QHBoxLayout* hLayout = new QHBoxLayout;
        hLayout->setMargin(0);
        topLayout->setMargin(0);
        topLayout->addLayout(hLayout);

        mSpaceSelector = this->createSpaceSelector();
        hLayout->addWidget(new SpaceEditWidget(widget, mSpaceSelector));

        mCoordinate =  this->createCoordinateSelector();
        topLayout->addWidget(Vector3DWidget::createSmallHorizontal(widget, mCoordinate));

        QWidget* sampleButton = this->createSampleButton(widget);
        hLayout->addWidget(sampleButton);

        this->addColorWidget(topLayout);
        topLayout->addStretch();
//      this->dataChangedSlot();

        return widget;
}

SpacePropertyPtr PointMetricWrapper::createSpaceSelector() const
{
        SpacePropertyPtr retval;
        retval = SpaceProperty::initialize("selectSpace",
                                                                                          "Space",
                                                                                          "Select coordinate system to store position in.");
        connect(retval.get(), SIGNAL(valueWasSet()), this, SLOT(spaceSelected()));
        retval->setSpaceProvider(mServices->spaceProvider());
        return retval;
}

Vector3DPropertyPtr PointMetricWrapper::createCoordinateSelector() const
{
        Vector3DPropertyPtr retval;
        retval = Vector3DProperty::initialize("selectCoordinate",
                                                                                                "Coord",
                                                                                                "Coordinate values.",
                                                                                                Vector3D(0,0,0),
                                                                                                DoubleRange(-1000,1000,1),
                                                                                                1,
                                                                                                QDomNode());

        connect(retval.get(), SIGNAL(valueWasSet()), this, SLOT(coordinateChanged()));
        return retval;
}

QWidget* PointMetricWrapper::createSampleButton(QWidget* parent) const
{
        QAction* sampleAction = new QAction("Sample", parent);
        QString sampleTip("Set the position equal to the current tool tip position.");
        sampleAction->setStatusTip(sampleTip);
        sampleAction->setWhatsThis(sampleTip);
        sampleAction->setToolTip(sampleTip);
        connect(sampleAction, SIGNAL(triggered()), this, SLOT(moveToToolPosition()));

        CXToolButton* sampleButton = new CXToolButton(parent);
        sampleButton->setDefaultAction(sampleAction);
        return sampleButton;
}

DataMetricPtr PointMetricWrapper::getData() const
{
        return mData;
}

QString PointMetricWrapper::getType() const
{
        return "point";
}

QString PointMetricWrapper::getArguments() const
{
        Vector3D p = mData->getCoordinate();
        QString coord = prettyFormat(p, 1, 1);
        if (mData->getSpace().mId==csREF)
                coord = ""; // ignore display of coord if in ref space

        return mData->getSpace().toString() + " " + coord;
}

void PointMetricWrapper::moveToToolPosition()
{
        Vector3D p = mServices->spaceProvider()->getActiveToolTipPoint(mData->getSpace(), true);
        mData->setCoordinate(p);
}

void PointMetricWrapper::spaceSelected()
{
        if (mInternalUpdate)
                return;
        CoordinateSystem space = mSpaceSelector->getValue();
        if (!space.isValid())
                return;
        mData->setSpace(space);
}

void PointMetricWrapper::coordinateChanged()
{
        if (mInternalUpdate)
                return;
        mData->setCoordinate(mCoordinate->getValue());
}

//void PointMetricWrapper::dataChangedSlot()
//{
//}

void PointMetricWrapper::update()
{
        mInternalUpdate = true;
        mSpaceSelector->setValue(mData->getSpace());
        mCoordinate->setValue(mData->getCoordinate());
        mInternalUpdate = false;
}

//---------------------------------------------------------
//---------------------------------------------------------
//---------------------------------------------------------

PlaneMetricWrapper::PlaneMetricWrapper(VisServicesPtr services, PlaneMetricPtr data) :
        MetricBase(services),
        mData(data),
        mArguments(services)
{
        mArguments.setArguments(data->getArguments());
        mInternalUpdate = false;
        connect(mData.get(), SIGNAL(transformChanged()), this, SLOT(dataChangedSlot()));
        connect(mData.get(), SIGNAL(propertiesChanged()), this, SLOT(dataChangedSlot()));
        connect(mServices->patient().get(), SIGNAL(dataAddedOrRemoved()), this, SLOT(dataChangedSlot()));
}

PlaneMetricWrapper::~PlaneMetricWrapper()
{
        disconnect(mServices->patient().get(), SIGNAL(dataAddedOrRemoved()), this, SLOT(dataChangedSlot()));
}

QWidget* PlaneMetricWrapper::createWidget()
{
        QWidget* widget = this->newWidget("plane_metric");
        QVBoxLayout* topLayout = new QVBoxLayout(widget);
        QHBoxLayout* hLayout = new QHBoxLayout;
        hLayout->setMargin(0);
        topLayout->setMargin(0);
        topLayout->addLayout(hLayout);

        mArguments.addWidgets(hLayout);
        this->addColorWidget(topLayout);
        topLayout->addStretch();

        this->dataChangedSlot();

        return widget;
}

DataMetricPtr PlaneMetricWrapper::getData() const
{
        return mData;
}

QString PlaneMetricWrapper::getType() const
{
        return "plane";
}

QString PlaneMetricWrapper::getArguments() const
{
        return mArguments.getAsString();
}

void PlaneMetricWrapper::dataChangedSlot()
{
//      mInternalUpdate = true;
        mInternalUpdate = false;
}

void PlaneMetricWrapper::update()
{
        mArguments.update();
}

//---------------------------------------------------------
//---------------------------------------------------------
//---------------------------------------------------------

DistanceMetricWrapper::DistanceMetricWrapper(VisServicesPtr services, DistanceMetricPtr data) :
        MetricBase(services),
        mData(data),
        mArguments(services)
{
        mArguments.setArguments(data->getArguments());
        mInternalUpdate = false;
        connect(mData.get(), SIGNAL(transformChanged()), this, SLOT(dataChangedSlot()));
        connect(mServices->patient().get(), SIGNAL(dataAddedOrRemoved()), this, SLOT(dataChangedSlot()));
}

QWidget* DistanceMetricWrapper::createWidget()
{
        QWidget* widget = this->newWidget("distance_metric");
        QVBoxLayout* topLayout = new QVBoxLayout(widget);
        QHBoxLayout* hLayout = new QHBoxLayout;
        hLayout->setMargin(0);
        topLayout->setMargin(0);
        topLayout->addLayout(hLayout);

        mArguments.addWidgets(hLayout);
        this->addColorWidget(topLayout);
        topLayout->addStretch();

        this->dataChangedSlot();
        return widget;
}

DataMetricPtr DistanceMetricWrapper::getData() const
{
        return mData;
}

QString DistanceMetricWrapper::getType() const
{
        return "distance";
}

QString DistanceMetricWrapper::getArguments() const
{
        return mArguments.getAsString();
}

void DistanceMetricWrapper::dataChangedSlot()
{
//      mInternalUpdate = true;
        mInternalUpdate = false;
}

void DistanceMetricWrapper::update()
{
        mArguments.update();
}


//---------------------------------------------------------
//---------------------------------------------------------
//---------------------------------------------------------

AngleMetricWrapper::AngleMetricWrapper(VisServicesPtr services, AngleMetricPtr data) :
        MetricBase(services),
        mData(data),
        mArguments(services)
{
        mArguments.setArguments(data->getArguments());
        mInternalUpdate = false;
        connect(mData.get(), SIGNAL(transformChanged()), this, SLOT(dataChangedSlot()));
        connect(mServices->patient().get(), SIGNAL(dataAddedOrRemoved()), this, SLOT(dataChangedSlot()));
}

AngleMetricWrapper::~AngleMetricWrapper()
{
        disconnect(mServices->patient().get(), SIGNAL(dataAddedOrRemoved()), this, SLOT(dataChangedSlot()));
}

QWidget* AngleMetricWrapper::createWidget()
{
        QWidget* widget = this->newWidget("angle_metric");
        QVBoxLayout* topLayout = new QVBoxLayout(widget);
        QHBoxLayout* hLayout = new QHBoxLayout;
        hLayout->setMargin(0);
        topLayout->setMargin(0);
        topLayout->addLayout(hLayout);

        mArguments.addWidgets(hLayout);

        mUseSimpleVisualization =  this->createUseSimpleVisualizationSelector();
        topLayout->addWidget(createDataWidget(mServices->view(), mServices->patient(), widget, mUseSimpleVisualization));

        this->addColorWidget(topLayout);
        topLayout->addStretch();

        this->dataChangedSlot();
        return widget;
}

DataMetricPtr AngleMetricWrapper::getData() const
{
        return mData;
}
QString AngleMetricWrapper::getType() const
{
        return "angle";
}

QString AngleMetricWrapper::getArguments() const
{
        return mArguments.getAsString();
}

void AngleMetricWrapper::dataChangedSlot()
{
        mInternalUpdate = true;
        mUseSimpleVisualization->setValue(mData->getUseSimpleVisualization());
        mInternalUpdate = false;
}

void AngleMetricWrapper::guiChanged()
{
        if (mInternalUpdate)
                return;
        mData->setUseSimpleVisualization(mUseSimpleVisualization->getValue());
}

BoolPropertyPtr AngleMetricWrapper::createUseSimpleVisualizationSelector() const
{
        BoolPropertyPtr retval;
        retval = BoolProperty::initialize("Simple Visualization", "",
                                                                                          "Simple Visualization",
                                                                                          mData->getUseSimpleVisualization());

        connect(retval.get(), SIGNAL(valueWasSet()), this, SLOT(guiChanged()));
        return retval;
}

void AngleMetricWrapper::update()
{
        mArguments.update();
}

//---------------------------------------------------------
//---------------------------------------------------------
//---------------------------------------------------------

DonutMetricWrapper::DonutMetricWrapper(VisServicesPtr services, DonutMetricPtr data) :
        MetricBase(services),
        mData(data),
        mArguments(services)
{
        mArguments.setArguments(data->getArguments());
        mInternalUpdate = false;
        connect(mData.get(), SIGNAL(propertiesChanged()), this, SLOT(dataChangedSlot()));
}

QWidget* DonutMetricWrapper::createWidget()
{
        QWidget* widget = this->newWidget("donut_metric");
        QVBoxLayout* topLayout = new QVBoxLayout(widget);
        QHBoxLayout* hLayout = new QHBoxLayout;
        hLayout->setMargin(0);
        topLayout->setMargin(0);
        topLayout->addLayout(hLayout);

        mArguments.addWidgets(hLayout);

        mRadius =  this->createRadiusSelector();
        topLayout->addWidget(createDataWidget(mServices->view(), mServices->patient(), widget, mRadius));
        mThickness =  this->createThicknessSelector();
        topLayout->addWidget(createDataWidget(mServices->view(), mServices->patient(), widget, mThickness));
        mFlat =  this->createFlatSelector();
        topLayout->addWidget(createDataWidget(mServices->view(), mServices->patient(), widget, mFlat));
        mHeight =  this->createHeightSelector();
        topLayout->addWidget(createDataWidget(mServices->view(), mServices->patient(), widget, mHeight));

        this->addColorWidget(topLayout);
        topLayout->addStretch();

        this->dataChangedSlot();
        return widget;
}

DataMetricPtr DonutMetricWrapper::getData() const
{
        return mData;
}
QString DonutMetricWrapper::getType() const
{
        return "donut";
}

QString DonutMetricWrapper::getArguments() const
{
        return mArguments.getAsString();
}

void DonutMetricWrapper::update()
{
        mArguments.update();

        if (mInternalUpdate)
                return;
        mInternalUpdate = true;
        mRadius->setValue(mData->getRadius());
        mThickness->setValue(mData->getThickness());
        mHeight->setValue(mData->getHeight());
        mFlat->setValue(mData->getFlat());
        mInternalUpdate = false;
}

void DonutMetricWrapper::dataChangedSlot()
{
//      if (mInternalUpdate)
//              return;
//      mInternalUpdate = true;
//      mRadius->setValue(mData->getRadius());
//      mThickness->setValue(mData->getThickness());
//      mFlat->setValue(mData->getFlat());
//      mInternalUpdate = false;
}

void DonutMetricWrapper::guiChanged()
{
        if (mInternalUpdate)
                return;
        mInternalUpdate = true;
        mData->setRadius(mRadius->getValue());
        mData->setThickness(mThickness->getValue());
        mData->setHeight(mHeight->getValue());
        mData->setFlat(mFlat->getValue());
        mInternalUpdate = false;
}


DoublePropertyPtr DonutMetricWrapper::createRadiusSelector() const
{
        DoublePropertyPtr retval;
        retval = DoubleProperty::initialize("selectRadius",
                                                                                          "Radius",
                                                                                          "Donut Radius",
                                                                                          mData->getRadius(),
                                                                                          DoubleRange(0, 50, 1),
                                                                                          1,
                                                                                          QDomNode());

        connect(retval.get(), SIGNAL(valueWasSet()), this, SLOT(guiChanged()));
        return retval;
}

DoublePropertyPtr DonutMetricWrapper::createThicknessSelector() const
{
        DoublePropertyPtr retval;
        retval = DoubleProperty::initialize("selectThickness",
                                                                                          "Thickness",
                                                                                          "Donut Thickness",
                                                                                          mData->getThickness(),
                                                                                          DoubleRange(0.05, 1, 0.05),
                                                                                          2,
                                                                                          QDomNode());

        connect(retval.get(), SIGNAL(valueWasSet()), this, SLOT(guiChanged()));
        return retval;
}

DoublePropertyPtr DonutMetricWrapper::createHeightSelector() const
{
        DoublePropertyPtr retval;
        retval = DoubleProperty::initialize("selectHeight",
                                                                                          "Height",
                                                                                          "Disc height, NA to torus",
                                                                                          mData->getHeight(),
                                                                                          DoubleRange(0.0, 100, 1),
                                                                                          1,
                                                                                          QDomNode());

        connect(retval.get(), SIGNAL(valueWasSet()), this, SLOT(guiChanged()));
        return retval;
}

BoolPropertyPtr DonutMetricWrapper::createFlatSelector() const
{
        BoolPropertyPtr retval;
        retval = BoolProperty::initialize("selectFlat",
                                                                                          "Flat",
                                                                                          "Flat disk or torus",
                                                                                          mData->getFlat(),
                                                                                          QDomNode());

        connect(retval.get(), SIGNAL(valueWasSet()), this, SLOT(guiChanged()));
        return retval;
}
//---------------------------------------------------------
//---------------------------------------------------------
//---------------------------------------------------------

CustomMetricWrapper::CustomMetricWrapper(VisServicesPtr services, CustomMetricPtr data) :
        MetricBase(services),
        mData(data),
        mScaleToP1Widget(NULL),
        mArguments(services)
{
    mArguments.setArguments(data->getArguments());
    mInternalUpdate = false;
        connect(mData.get(), SIGNAL(propertiesChanged()), this, SLOT(dataChangedSlot()));
}

QWidget* CustomMetricWrapper::createWidget()
{
        QWidget* widget = this->newWidget("custom_metric");
    QVBoxLayout* topLayout = new QVBoxLayout(widget);
    QHBoxLayout* hLayout = new QHBoxLayout;
    hLayout->setMargin(0);
    topLayout->setMargin(0);
    topLayout->addLayout(hLayout);

    mArguments.addWidgets(hLayout);

    mDefineVectorUpMethod =  this->createDefineVectorUpMethodSelector();
        topLayout->addWidget(createDataWidget(mServices->view(), mServices->patient(), widget, mDefineVectorUpMethod));
        mModel = this->createModelSelector();
        topLayout->addWidget(createDataWidget(mServices->view(), mServices->patient(), widget, mModel));

        mOffsetFromP0 = this->createOffsetFromP0();
        topLayout->addWidget(createDataWidget(mServices->view(), mServices->patient(), widget, mOffsetFromP0));
        mOffsetFromP1 = this->createOffsetFromP1();
        topLayout->addWidget(createDataWidget(mServices->view(), mServices->patient(), widget, mOffsetFromP1));
        mRepeatDistance = this->createRepeatDistance();
        topLayout->addWidget(createDataWidget(mServices->view(), mServices->patient(), widget, mRepeatDistance));

        mShowDistanceMarkers = this->createShowDistanceMarkers();
        topLayout->addWidget(createDataWidget(mServices->view(), mServices->patient(), widget, mShowDistanceMarkers));
        mDistanceMarkerVisibility = this->createDistanceMarkerVisibility();
        mDistanceMarkerVisibilityWidget = createDataWidget(mServices->view(), mServices->patient(), widget, mDistanceMarkerVisibility);
        topLayout->addWidget(mDistanceMarkerVisibilityWidget);

        mScaleToP1 = this->createScaletoP1();
        mScaleToP1Widget = createDataWidget(mServices->view(), mServices->patient(), widget, mScaleToP1);
        topLayout->addWidget(mScaleToP1Widget);

        mTranslationOnly= this->createTranslationOnly();
        topLayout->addWidget(createDataWidget(mServices->view(), mServices->patient(), widget, mTranslationOnly));

        mTextureFollowTool= this->createTextureFollowTool();
        topLayout->addWidget(createDataWidget(mServices->view(), mServices->patient(), widget, mTextureFollowTool));

    this->addColorWidget(topLayout);
    topLayout->addStretch();

        this->dataChangedSlot();
    return widget;
}

DataMetricPtr CustomMetricWrapper::getData() const
{
    return mData;
}
QString CustomMetricWrapper::getType() const
{
    return "Custom";
}

QString CustomMetricWrapper::getArguments() const
{
    return mArguments.getAsString();
}

void CustomMetricWrapper::update()
{
    mArguments.update();

    if (mInternalUpdate)
        return;
    mInternalUpdate = true;
    mDefineVectorUpMethod->setValue(mData->getDefineVectorUpMethod());
        mModel->setValue(mData->getModelUid());
    mInternalUpdate = false;
        guiChanged();
}

void CustomMetricWrapper::dataChangedSlot()
{
//      if (mInternalUpdate)
//              return;
//      mInternalUpdate = true;
//      mRadius->setValue(mData->getRadius());
//      mThickness->setValue(mData->getThickness());
//      mFlat->setValue(mData->getFlat());
//      mInternalUpdate = false;
}

void CustomMetricWrapper::guiChanged()
{
    if (mInternalUpdate)
        return;

        if(mModel->getData() && mModel->getData()->getType() == "image")
                mScaleToP1Widget->setEnabled(false);
        else
                mScaleToP1Widget->setEnabled(true);

        if(mShowDistanceMarkers->getValue())
                mDistanceMarkerVisibilityWidget->setEnabled(true);
        else
                mDistanceMarkerVisibilityWidget->setEnabled(false);

    mInternalUpdate = true;
    mData->setDefineVectorUpMethod(mDefineVectorUpMethod->getValue());
        mData->setModelUid(mModel->getValue());
        mData->setOffsetFromP0(mOffsetFromP0->getValue());
        mData->setOffsetFromP1(mOffsetFromP1->getValue());
        mData->setRepeatDistance(mRepeatDistance->getValue());
        mData->setScaleToP1(mScaleToP1->getValue());
        mData->setShowDistanceMarkers(mShowDistanceMarkers->getValue());
        mData->setDistanceMarkerVisibility(mDistanceMarkerVisibility->getValue());
        mData->setTranslationOnly(mTranslationOnly->getValue());
        mData->setTextureFollowTool(mTextureFollowTool->getValue());

        mInternalUpdate = false;
}

BoolPropertyPtr CustomMetricWrapper::createScaletoP1() const
{
        BoolPropertyPtr retval;
        retval = BoolProperty::initialize("Scale to P1", "",
                                                                                  "Scale model so that it fits between P0 and P1",
                                                                                  mData->getScaleToP1());
        connect(retval.get(), SIGNAL(valueWasSet()), this, SLOT(guiChanged()));
        return retval;
}

BoolPropertyPtr CustomMetricWrapper::createShowDistanceMarkers() const
{
        BoolPropertyPtr retval;
        retval = BoolProperty::initialize("Show distance markers", "",
                                                                                  "Show distance to P0 for each repeated model",
                                                                                  mData->getShowDistanceMarkers());
        connect(retval.get(), SIGNAL(valueWasSet()), this, SLOT(guiChanged()));
        return retval;
}

BoolPropertyPtr CustomMetricWrapper::createTranslationOnly() const
{
        BoolPropertyPtr retval;
        retval = BoolProperty::initialize("Translation Only", "",
                                                                                  "Ignore scale and rotate",
                                                                                  mData->getTranslationOnly());
        connect(retval.get(), SIGNAL(valueWasSet()), this, SLOT(guiChanged()));
        return retval;
}

BoolPropertyPtr CustomMetricWrapper::createTextureFollowTool() const
{
        BoolPropertyPtr retval;
        retval = BoolProperty::initialize("Texture Follow Tool", "",
                                                                                  "Any texture on the model will move with the tool",
                                                                                  mData->getTextureFollowTool());
        connect(retval.get(), SIGNAL(valueWasSet()), this, SLOT(guiChanged()));
        return retval;
}

DoublePropertyPtr CustomMetricWrapper::createOffsetFromP0() const
{
        DoublePropertyPtr retval;
        retval = DoubleProperty::initialize("Offset from P0", "",
                                                                                        "Position model an offset from P0 towards P1",
                                                                                        mData->getOffsetFromP0(), DoubleRange(-100, 100, 1), 0);
        connect(retval.get(), SIGNAL(valueWasSet()), this, SLOT(guiChanged()));
        return retval;
}

DoublePropertyPtr CustomMetricWrapper::createOffsetFromP1() const
{
        DoublePropertyPtr retval;
        retval = DoubleProperty::initialize("Offset from P1", "",
                                                                                        "When scaling to P1, scale to a point offset from P1 towards P0",
                                                                                        mData->getOffsetFromP1(), DoubleRange(-100, 100, 1), 0);
        connect(retval.get(), SIGNAL(valueWasSet()), this, SLOT(guiChanged()));
        return retval;
}

DoublePropertyPtr CustomMetricWrapper::createRepeatDistance() const
{
        DoublePropertyPtr retval;
        retval = DoubleProperty::initialize("Repeat Distance", "",
                                                                                        "Repeat model with this distance",
                                                                                        mData->getRepeatDistance(), DoubleRange(0, 100, 1), 0);
        connect(retval.get(), SIGNAL(valueWasSet()), this, SLOT(guiChanged()));
        return retval;
}

DoublePropertyPtr CustomMetricWrapper::createDistanceMarkerVisibility() const
{
        DoublePropertyPtr retval;
        retval = DoubleProperty::initialize("Distance markers visibility threshold", "",
                                                                                        "Hide the markers if the distance to the camera exceeds this threshold",
                                                                                        mData->getDistanceMarkerVisibility(), DoubleRange(0, 1000, 1), 0);
        connect(retval.get(), SIGNAL(valueWasSet()), this, SLOT(guiChanged()));
        return retval;
}

StringPropertyPtr CustomMetricWrapper::createDefineVectorUpMethodSelector() const
{
        StringPropertyPtr retval;
        retval = StringProperty::initialize("selectDefineVectorUp",
                                                                                "Use to define the vector up",
                                                                                "The vector up of the metric will be connected to one of:\n"
                                                                                "- a) The static up vector of the operating table\n"
                                                                                "- b) To a frame in p1, which might well be connected "
                                                                                "to a tool giving a dynamic up vector.\n"
                                                                                "- c) The tool up (tool negative x)",
                                                                                mData->getDefineVectorUpMethod(),
                                                                                mData->getDefineVectorUpMethods().getAvailableDefineVectorUpMethods(),
                                                                                QDomNode());
        retval->setDisplayNames(mData->getDefineVectorUpMethods().getAvailableDefineVectorUpMethodsDisplayNames());


        connect(retval.get(), SIGNAL(valueWasSet()), this, SLOT(guiChanged()));
        return retval;
}

StringPropertySelectDataPtr CustomMetricWrapper::createModelSelector() const
{
        StringPropertySelectDataPtr retval;
        retval = StringPropertySelectData::New(mServices->patient(), "image|mesh");
        retval->setOnly2DImagesFilter(true);
        retval->setValueName("Model");
        retval->setHelp("Model can be mesh or 2D image");
        connect(retval.get(), &StringPropertySelectData::changed, this, &CustomMetricWrapper::guiChanged);
        return retval;
}

//---------------------------------------------------------
//---------------------------------------------------------
//---------------------------------------------------------

SphereMetricWrapper::SphereMetricWrapper(VisServicesPtr services, SphereMetricPtr data) :
        MetricBase(services),
        mData(data),
        mArguments(services)
{
        mArguments.setArguments(data->getArguments());
        mInternalUpdate = false;
        connect(mData.get(), SIGNAL(propertiesChanged()), this, SLOT(dataChangedSlot()));
}

QWidget* SphereMetricWrapper::createWidget()
{
        QWidget* widget = this->newWidget("sphere_metric");
        QVBoxLayout* topLayout = new QVBoxLayout(widget);
        QHBoxLayout* hLayout = new QHBoxLayout;
        hLayout->setMargin(0);
        topLayout->setMargin(0);
        topLayout->addLayout(hLayout);

        mArguments.addWidgets(hLayout);

        mRadius =  this->createRadiusSelector();
        topLayout->addWidget(createDataWidget(mServices->view(), mServices->patient(), widget, mRadius));

        this->addColorWidget(topLayout);
        topLayout->addStretch();

        this->dataChangedSlot();
        return widget;
}

DataMetricPtr SphereMetricWrapper::getData() const
{
        return mData;
}
QString SphereMetricWrapper::getType() const
{
        return "sphere";
}

QString SphereMetricWrapper::getArguments() const
{
        return mArguments.getAsString();
}

void SphereMetricWrapper::dataChangedSlot()
{

}

void SphereMetricWrapper::update()
{
        mArguments.update();
        mInternalUpdate = true;
        mRadius->setValue(mData->getRadius());
        mInternalUpdate = false;
}

void SphereMetricWrapper::guiChanged()
{
        if (mInternalUpdate)
                return;
        mData->setRadius(mRadius->getValue());
}

DoublePropertyPtr SphereMetricWrapper::createRadiusSelector() const
{
        DoublePropertyPtr retval;
        retval = DoubleProperty::initialize("selectRadius",
                                                                                          "Radius",
                                                                                          "Sphere Radius",
                                                                                          mData->getRadius(),
                                                                                          DoubleRange(0, 50, 0.5),
                                                                                          1,
                                                                                          QDomNode());

        connect(retval.get(), SIGNAL(valueWasSet()), this, SLOT(guiChanged()));
        return retval;
}

//---------------------------------------------------------
//---------------------------------------------------------
//---------------------------------------------------------

RegionOfInterestMetricWrapper::RegionOfInterestMetricWrapper(VisServicesPtr services, RegionOfInterestMetricPtr data) :
        MetricBase(services),
        mData(data)
{
        mInternalUpdate = false;
        connect(mData.get(), SIGNAL(propertiesChanged()), this, SLOT(dataChangedSlot()));
}

QWidget* RegionOfInterestMetricWrapper::createWidget()
{
        QWidget* widget = this->newWidget("region_of_interest_metric");
        QVBoxLayout* topLayout = new QVBoxLayout(widget);
        QHBoxLayout* hLayout = new QHBoxLayout;
        hLayout->setMargin(0);
        topLayout->setMargin(0);
        topLayout->addLayout(hLayout);

        mDataListProperty = this->createDataListProperty();
        StringListSelectWidget* datalistwidget = new StringListSelectWidget(widget, mDataListProperty);
        topLayout->addWidget(datalistwidget);

        mUseActiveTooltipProperty = this->createUseActiveTooltipSelector();
        topLayout->addWidget(createDataWidget(mServices->view(), mServices->patient(), widget, mUseActiveTooltipProperty));

        mMaxBoundsDataProperty = this->createMaxBoundsDataSelector();
        topLayout->addWidget(createDataWidget(mServices->view(), mServices->patient(), widget, mMaxBoundsDataProperty));

        mMarginProperty = this->createMarginSelector();
        topLayout->addWidget(createDataWidget(mServices->view(), mServices->patient(), widget, mMarginProperty));

        this->addColorWidget(topLayout);
        topLayout->addStretch();

        this->dataChangedSlot();
        return widget;
}

DataMetricPtr RegionOfInterestMetricWrapper::getData() const
{
        return mData;
}
QString RegionOfInterestMetricWrapper::getType() const
{
        return "roi";
}

QString RegionOfInterestMetricWrapper::getArguments() const
{
        return "";
}

void RegionOfInterestMetricWrapper::dataChangedSlot()
{

}

StringListPropertyPtr RegionOfInterestMetricWrapper::createDataListProperty()
{
        StringListPropertyPtr retval = StringListProperty::initialize("data_list",
                                                                                                                "Data",
                                                                                                                "Select data to define ROI",
                                                                                                                QStringList(),
                                                                                                                QStringList());
        connect(retval.get(), &Property::changed, this, &RegionOfInterestMetricWrapper::guiChanged);
        return retval;
}

StringPropertyPtr RegionOfInterestMetricWrapper::createMaxBoundsDataSelector()
{
        StringPropertyPtr retval;
        retval = StringProperty::initialize("max_bounds_data",
                                                                                "Max Bounds",
                                                                                "Select data to define maximal extent of ROI",
                                                                                "",
                                                                                QStringList(),
                                                                                QDomNode());
        connect(retval.get(), &Property::changed, this, &RegionOfInterestMetricWrapper::guiChanged);
        return retval;
}

DoublePropertyPtr RegionOfInterestMetricWrapper::createMarginSelector() const
{
        DoublePropertyPtr retval;
        retval = DoubleProperty::initialize("margin",
                                                                                "Margin",
                                                                                "Margin added outside the data",
                                                                                0,
                                                                                DoubleRange(0, 100, 1),
                                                                                1,
                                                                                QDomNode());

        connect(retval.get(), SIGNAL(valueWasSet()), this, SLOT(guiChanged()));
        return retval;
}

BoolPropertyPtr RegionOfInterestMetricWrapper::createUseActiveTooltipSelector() const
{
        BoolPropertyPtr retval;
        retval = BoolProperty::initialize("Use Tool Tip", "",
                                                                                          "Include tool tip in the roi",
                                                                                          false);

        connect(retval.get(), &Property::changed, this, &RegionOfInterestMetricWrapper::guiChanged);
        return retval;
}


void RegionOfInterestMetricWrapper::update()
{
        mInternalUpdate = true;

        QStringList data;
        std::map<QString, QString> names;
        std::map<QString, DataPtr> alldata = mServices->patient()->getDatas();
        for (std::map<QString, DataPtr>::iterator i=alldata.begin(); i!=alldata.end(); ++i)
        {
                if (i->first == mData->getUid())
                        continue;
                data << i->first;
                names[i->first] = i->second->getName();
        }

        mDataListProperty->setValue(mData->getDataList());
        mDataListProperty->setValueRange(data);
        mDataListProperty->setDisplayNames(names);

        mMaxBoundsDataProperty->setValue(mData->getMaxBoundsData());
        mMaxBoundsDataProperty->setValueRange(data);
        mMaxBoundsDataProperty->setDisplayNames(names);

        mMarginProperty->setValue(mData->getMargin());
        mUseActiveTooltipProperty->setValue(mData->getUseActiveTooltip());

        mInternalUpdate = false;
}

void RegionOfInterestMetricWrapper::guiChanged()
{
        if (mInternalUpdate)
                return;
        mData->setDataList(mDataListProperty->getValue());
        mData->setUseActiveTooltip(mUseActiveTooltipProperty->getValue());
        mData->setMargin(mMarginProperty->getValue());
        mData->setMaxBoundsData(mMaxBoundsDataProperty->getValue());
}

}