cxDataInterface.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 "cxDataInterface.h"
#include "cxImage.h"
#include <QSet>
#include "cxMesh.h"
#include "cxImageLUT2D.h"
#include "cxTrackingService.h"
#include "cxTypeConversions.h"
#include "cxTool.h"
#include "cxImageAlgorithms.h"
#include "cxRegistrationTransform.h"
#include "cxLogger.h"
#include "cxActiveImageProxy.h"
#include "cxVideoSource.h"
#include "cxVideoService.h"
#include "cxPatientModelService.h"
#include "cxActiveToolProxy.h"
#include "cxActiveData.h"
#include "cxEnumConversion.h"

namespace cx
{
DoublePropertyActiveToolOffset::DoublePropertyActiveToolOffset(ActiveToolProxyPtr activeTool) :
        mActiveTool(activeTool)
{
        connect(mActiveTool.get(), &ActiveToolProxy::tooltipOffset, this, &Property::changed);
}

double DoublePropertyActiveToolOffset::getValue() const
{
        return mActiveTool->getTool()->getTooltipOffset();
}

bool DoublePropertyActiveToolOffset::setValue(double val)
{
        mActiveTool->getTool()->setTooltipOffset(val);
        return true;
}

DoubleRange DoublePropertyActiveToolOffset::getValueRange() const
{
        double range = 200;
        return DoubleRange(0,range,1);
}

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

DoublePropertyToolOffset::DoublePropertyToolOffset(ToolPtr tool) :
        mTool(tool)
{
        this->setTool(tool);
}

void DoublePropertyToolOffset::setTool(ToolPtr tool)
{
        if (mTool)
                disconnect(mTool.get(), &Tool::tooltipOffset, this, &Property::changed);
        mTool = tool;
        if (mTool)
                connect(mTool.get(), &Tool::tooltipOffset, this, &Property::changed);
        emit changed();
}

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

bool DoublePropertyToolOffset::setValue(double val)
{
        mTool->setTooltipOffset(val);
        return true;
}

DoubleRange DoublePropertyToolOffset::getValueRange() const
{
        double range = 200;
        return DoubleRange(0,range,1);
}


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

DoublePropertyActiveImageBase::DoublePropertyActiveImageBase(ActiveDataPtr activeData) :
        mActiveData(activeData)
{
        mActiveImageProxy = ActiveImageProxy::New(mActiveData);
        connect(mActiveImageProxy.get(), &ActiveImageProxy::activeImageChanged, this, &DoublePropertyActiveImageBase::activeImageChanged);
        connect(mActiveImageProxy.get(), &ActiveImageProxy::transferFunctionsChanged, this, &Property::changed);
}
void DoublePropertyActiveImageBase::activeImageChanged()
{
        mImage = mActiveData->getActive<Image>();
        emit changed();
}
double DoublePropertyActiveImageBase::getValue() const
{
        if (!mImage)
                return 0.0;
        return getValueInternal();
}
bool DoublePropertyActiveImageBase::setValue(double val)
{
        if (!mImage)
                return false;
        setValueInternal(val);
        return true;
}

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

double DoubleProperty2DWindow::getValueInternal() const
{
        return mImage->getLookupTable2D()->getWindow();
}
void DoubleProperty2DWindow::setValueInternal(double val)
{
        mImage->getLookupTable2D()->setWindow(val);
}
DoubleRange DoubleProperty2DWindow::getValueRange() const
{
        if (!mImage)
                return DoubleRange();
        double range = mImage->getRange();
        return DoubleRange(1,range,range/1000.0);
}

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

double DoubleProperty2DLevel::getValueInternal() const
{
        return mImage->getLookupTable2D()->getLevel();
}
void DoubleProperty2DLevel::setValueInternal(double val)
{
        mImage->getLookupTable2D()->setLevel(val);
}
DoubleRange DoubleProperty2DLevel::getValueRange() const
{
        if (!mImage)
                return DoubleRange();

        double max = mImage->getMax();
        return DoubleRange(1,max,max/1000.0);
}


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


StringPropertyParentFrame::StringPropertyParentFrame(PatientModelServicePtr patientModelService) :
        mPatientModelService(patientModelService)
{
        connect(mPatientModelService.get(), &PatientModelService::dataAddedOrRemoved, this, &Property::changed);
}

void StringPropertyParentFrame::setData(DataPtr data)
{
        if (mData)
                disconnect(mData.get(), &Data::transformChanged, this, &Property::changed);
        mData = data;
        if (mData)
                connect(mData.get(), &Data::transformChanged, this, &Property::changed);
        emit changed();
}

StringPropertyParentFrame::~StringPropertyParentFrame()
{
        disconnect(mPatientModelService.get(), &PatientModelService::dataAddedOrRemoved, this, &Property::changed);
}

QString StringPropertyParentFrame::getDisplayName() const
{
        return "Parent Frame";
}

bool StringPropertyParentFrame::setValue(const QString& value)
{
        if (!mData)
                return false;
        mData->get_rMd_History()->addParentSpace(value);
        return true;
}

QString StringPropertyParentFrame::getValue() const
{
        if (!mData)
                return "";
        return qstring_cast(mData->getParentSpace());
}

QString StringPropertyParentFrame::getHelp() const
{
        if (!mData)
                return "";
        return "Select the parent frame for " + qstring_cast(mData->getName()) + ".";
}

QStringList StringPropertyParentFrame::getValueRange() const
{
        QStringList retval;
        retval << "";

        std::map<QString, DataPtr> allData = mPatientModelService->getDatas();
        for (std::map<QString, DataPtr>::iterator iter=allData.begin(); iter!=allData.end(); ++iter)
        {
                if (mData && (mData->getUid() == iter->first))
                        continue;

                retval << qstring_cast(iter->first);
        }
        return retval;
}

QString StringPropertyParentFrame::convertInternal2Display(QString internal)
{
        DataPtr data = mPatientModelService->getData(internal);
        if (!data)
                return "<no data>";
        return qstring_cast(data->getName());
}

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

StringPropertySetParentFrame::StringPropertySetParentFrame(PatientModelServicePtr patientModelService) :
        StringPropertyParentFrame(patientModelService)
{
}

bool StringPropertySetParentFrame::setValue(const QString& value)
{
        if (!mData)
                return false;
        mData->get_rMd_History()->setParentSpace(value);
        emit parentChanged();
        return true;
}

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

StringPropertyDataNameEditable::StringPropertyDataNameEditable()
{
}

QString StringPropertyDataNameEditable::getDisplayName() const
{
        return "Name";
}

bool StringPropertyDataNameEditable::setValue(const QString& value)
{
        if (!mData)
                return false;
        mData->setName(value);
        return true;
}

QString StringPropertyDataNameEditable::getValue() const
{
        if (mData)
                return mData->getName();
        return "";
}

void StringPropertyDataNameEditable::setData(DataPtr data)
{
        mData = data;
        emit changed();
}

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

StringPropertyDataUidEditable::StringPropertyDataUidEditable()
{
}

QString StringPropertyDataUidEditable::getDisplayName() const
{
        return "Uid";
}

bool StringPropertyDataUidEditable::setValue(const QString& value)
{
        return false;
}

QString StringPropertyDataUidEditable::getValue() const
{
        if (mData)
                return mData->getUid();
        return "";
}

void StringPropertyDataUidEditable::setData(DataPtr data)
{
        mData = data;
        emit changed();
}

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

StringPropertyDataModality::StringPropertyDataModality(PatientModelServicePtr patientModelService) :
        mPatientModelService(patientModelService)
{
        connect(mPatientModelService.get(), &PatientModelService::dataAddedOrRemoved, this, &Property::changed);
}

StringPropertyDataModality::~StringPropertyDataModality()
{
        disconnect(mPatientModelService.get(), &PatientModelService::dataAddedOrRemoved, this, &Property::changed);
}

void StringPropertyDataModality::setData(ImagePtr data)
{
        if (mData)
                disconnect(mData.get(), &Data::propertiesChanged, this, &Property::changed);
        mData = data;
        if (mData)
                connect(mData.get(), &Data::propertiesChanged, this, &Property::changed);
        emit changed();
}

QString StringPropertyDataModality::getDisplayName() const
{
        return "Modality";
}

bool StringPropertyDataModality::setValue(const QString& value)
{
        if (!mData)
                return false;
        mData->setModality(string2enum<IMAGE_MODALITY>(value));
        return true;
}

QString StringPropertyDataModality::getValue() const
{
        if (!mData)
                return "";
        return enum2string(mData->getModality());
}

QString StringPropertyDataModality::getHelp() const
{
        if (!mData)
                return "";
        return "Select the modality for " + qstring_cast(mData->getName()) + ".";
}

QStringList StringPropertyDataModality::getValueRange() const
{
        QStringList retval;
        retval << "";
        if (mData)
                retval << enum2string(mData->getModality());
        retval << enum2string(imCT) << enum2string(imMR) << enum2string(imUS);
        return QStringList::fromSet(QSet<QString>::fromList(retval));
}

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

StringPropertyImageType::StringPropertyImageType(PatientModelServicePtr patientModelService) :
        mPatientModelService(patientModelService)
{
        connect(mPatientModelService.get(), &PatientModelService::dataAddedOrRemoved, this, &Property::changed);
}

void StringPropertyImageType::setData(ImagePtr data)
{
        if (mData)
                disconnect(mData.get(), &Data::propertiesChanged, this, &Property::changed);
        mData = data;
        if (mData)
                connect(mData.get(), &Data::propertiesChanged, this, &Property::changed);
        emit changed();
}

StringPropertyImageType::~StringPropertyImageType()
{
        disconnect(mPatientModelService.get(), &PatientModelService::dataAddedOrRemoved, this, &Property::changed);
}

QString StringPropertyImageType::getDisplayName() const
{
        return "Image Type";
}

bool StringPropertyImageType::setValue(const QString& value)
{
        if (!mData)
                return false;
        mData->setImageType(string2enum<IMAGE_SUBTYPE>(value));
        return true;
}

QString StringPropertyImageType::getValue() const
{
        if (!mData)
                return "";
        return enum2string(mData->getImageType());
}

QString StringPropertyImageType::getHelp() const
{
        if (!mData)
                return "";
        return "Select the image type for " + qstring_cast(mData->getName()) + ".";
}

QStringList StringPropertyImageType::getValueRange() const
{
        QStringList retval;
        retval << "";
        if (mData)
        {
                retval << enum2string(mData->getImageType());
                if (mData->getModality() == imCT)
                        retval << enum2string(istSEGMENTATION);
                if (mData->getModality() == imMR)
                        retval << enum2string(istMRT1) << enum2string(istMRT2) << enum2string(istMRFLAIR) << enum2string(istANGIO) << enum2string(istSEGMENTATION);
                if (mData->getModality() == imUS)
                        retval << enum2string(istUSBMODE) << enum2string(istANGIO) << enum2string(istSEGMENTATION);
        }
        return QStringList::fromSet(QSet<QString>::fromList(retval));
}

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

StringPropertyGlyphOrientationArray::StringPropertyGlyphOrientationArray(PatientModelServicePtr patientModelService) :
        mPatientModelService(patientModelService)
{
        connect(mPatientModelService.get(), &PatientModelService::dataAddedOrRemoved, this, &Property::changed);
}

StringPropertyGlyphOrientationArray::~StringPropertyGlyphOrientationArray()
{
        disconnect(mPatientModelService.get(), &PatientModelService::dataAddedOrRemoved, this, &Property::changed);
}

void StringPropertyGlyphOrientationArray::setData(MeshPtr data)
{
        if (mData)
                disconnect(mData.get(), &Data::propertiesChanged, this, &Property::changed);
        mData = data;
        if (mData)
                connect(mData.get(), &Data::propertiesChanged, this, &Property::changed);
        emit changed();
}

QString StringPropertyGlyphOrientationArray::getDisplayName() const
{
        return "Set glyph orientation array";
}

bool StringPropertyGlyphOrientationArray::setValue(const QString& value)
{
        if (!mData)
                return false;
        mData->setOrientationArray(value.toStdString().c_str());
        return true;
}

QString StringPropertyGlyphOrientationArray::getValue() const
{
        if (!mData)
                return "";
        return mData->getOrientationArray();
}

QString StringPropertyGlyphOrientationArray::getHelp() const
{
        if (!mData)
                return "";
        return "Select which array to use for orientation of the glyphs.";
}

QStringList StringPropertyGlyphOrientationArray::getValueRange() const
{
        if (!mData)
        {
                QStringList retval;
                retval << "";
                return retval;
        }
        return mData->getOrientationArrayList();
}
//---------------------------------------------------------
//---------------------------------------------------------
//---------------------------------------------------------

StringPropertyGlyphColorArray::StringPropertyGlyphColorArray(PatientModelServicePtr patientModelService) :
        mPatientModelService(patientModelService)
{
        connect(mPatientModelService.get(), &PatientModelService::dataAddedOrRemoved, this, &Property::changed);
}

StringPropertyGlyphColorArray::~StringPropertyGlyphColorArray()
{
        disconnect(mPatientModelService.get(), &PatientModelService::dataAddedOrRemoved, this, &Property::changed);
}

void StringPropertyGlyphColorArray::setData(MeshPtr data)
{
        if (mData)
                disconnect(mData.get(), &Data::propertiesChanged, this, &Property::changed);
        mData = data;
        if (mData)
                connect(mData.get(), &Data::propertiesChanged, this, &Property::changed);
        emit changed();
}

QString StringPropertyGlyphColorArray::getDisplayName() const
{
        return "Set glyph color array";
}

bool StringPropertyGlyphColorArray::setValue(const QString& value)
{
        if (!mData)
                return false;
        mData->setColorArray(value.toStdString().c_str());
        return true;
}

QString StringPropertyGlyphColorArray::getValue() const
{
        if (!mData)
                return "";
        return mData->getColorArray();
}

QString StringPropertyGlyphColorArray::getHelp() const
{
        if (!mData)
                return "";
        return "Select which array to use for coloring the glyphs.";
}

QStringList StringPropertyGlyphColorArray::getValueRange() const
{
        if (!mData)
        {
                QStringList retval;
                retval << "";
                return retval;
        }
        return mData->getColorArrayList();
}

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

StringPropertyGlyphLUT::StringPropertyGlyphLUT(PatientModelServicePtr patientModelService) :
        mPatientModelService(patientModelService)
{
        connect(mPatientModelService.get(), &PatientModelService::dataAddedOrRemoved, this, &Property::changed);
}

StringPropertyGlyphLUT::~StringPropertyGlyphLUT()
{
        disconnect(mPatientModelService.get(), &PatientModelService::dataAddedOrRemoved, this, &Property::changed);
}

void StringPropertyGlyphLUT::setData(MeshPtr data)
{
        if (mData)
                disconnect(mData.get(), &Data::propertiesChanged, this, &Property::changed);
        mData = data;
        if (mData)
                connect(mData.get(), &Data::propertiesChanged, this, &Property::changed);
        emit changed();
}

QString StringPropertyGlyphLUT::getDisplayName() const
{
        return "Set glyph color LUT";
}

bool StringPropertyGlyphLUT::setValue(const QString& value)
{
        if (!mData)
                return false;
        mData->setGlyphLUT(value.toStdString().c_str());
        return true;
}

QString StringPropertyGlyphLUT::getValue() const
{
        if (!mData)
                return "";
        return mData->getGlyphLUT();
}

QString StringPropertyGlyphLUT::getHelp() const
{
        if (!mData)
                return "";
        return "Select which color LUT to use for coloring the glyphs.";
}

QStringList StringPropertyGlyphLUT::getValueRange() const
{
        QStringList retval;

        retval <<
                          "Spectrum"<<
                          "Warm"<<
                          "Cool"<<
                          "Blues"<<
                          "Wild Flower"<<
                          "Citrus"<<

                          "Brewer Diverging Purple-Orange"<<
                          "Brewer Diverging Spectral"<<
                          "Brewer Diverging Brown-Blue-Green"<<

                          "Brewer Sequential Blue-Green"<<
                          "Brewer Sequential Yellow-Orange-Brown"<<
                          "Brewer Sequential Blue-Purple"<<

                          "Brewer Qualitative Accent"<<
                          "Brewer Qualitative Dark2"<<
                          "Brewer Qualitative Set2"<<
                          "Brewer Qualitative Pastel2"<<
                          "Brewer Qualitative Pastel1"<<
                          "Brewer Qualitative Set1"<<
                          "Brewer Qualitative Paired"<<
                          "Brewer Qualitative Set3";

        return retval;
}


} // namespace cx