sensormanipulator.h

Go to the documentation of this file.

 
/*
 * This file depends on Qt which is licensed under LGPLv3.
 * See ADTF_DIR/3rdparty/qt5 and doc/license for detailed information.
 */

 
#pragma once
 
#include <disptb/mixin/mixin_types.h>
 
#include <QWidget>
#include <QFrame>
#include <QLabel>
#include <QLayout>
#include <QLineEdit>
#include <QSlider>
#include <QString>
#include <QCloseEvent>
 
#include <cmath>
#ifndef M_PI
namespace
{
const double M_PI = std::acos(-1.0);
const double M_PI_2 = M_PI / 2.0;
} // namespace
#endif
 
#ifndef DEG2RAD
    #define DEG2RAD(angle) ((angle) * M_PI / 180.0)
#endif
#ifndef RAD2DEG
    #define RAD2DEG(angle) ((angle) * 180.0 / M_PI)
#endif
 
namespace adtf
{
 
namespace disptb
{
 
namespace mixinlib
{
 
namespace endor
{

class cSensorManipulator : public QWidget
{
    // Removed Q_OBJECT for switch to interface library
public:
    class Delegate
    {
    public:
        virtual void ValuesChangedInManipulator(cSensorManipulator* pManip) = 0;
    };
 
    explicit cSensorManipulator(QWidget* parent = nullptr, Qt::WindowFlags flags = Qt::Widget): QWidget(parent)
    {
        setWindowFlags(flags);
 
        int row = 0;
        auto pLayout = new QGridLayout;
        auto pLabel = new QLabel("Roll [degrees]", this);
 
        pLayout->addWidget(pLabel, row, 0);
 
        m_pRollSlider = new QSlider(Qt::Horizontal, this);
        m_pRollSlider->setMinimum(-1799);
        m_pRollSlider->setMaximum(1800);
        m_pRollSlider->setPageStep(10);
        m_pRollSlider->setValue(0);
        pLayout->addWidget(m_pRollSlider, row, 1);
        QObject::connect(m_pRollSlider, SIGNAL(valueChanged(int)), this, SLOT(rollChanged(int)));
 
        m_pRollLine = new QLineEdit;
        m_pRollLine->setText("0.0");
        pLayout->addWidget(m_pRollLine, row, 2);
        QObject::connect(m_pRollLine, SIGNAL(editingFinished()), this, SLOT(rollEditFinished()));
 
        row++;
 
        // pitch
 
        pLabel = new QLabel("Pitch [degrees]", this);
        pLayout->addWidget(pLabel, row, 0);
 
        m_pPitchSlider = new QSlider(Qt::Horizontal, this);
        m_pPitchSlider->setMinimum(-1799);
        m_pPitchSlider->setMaximum(1800);
        m_pPitchSlider->setPageStep(10);
        m_pPitchSlider->setValue(0);
        pLayout->addWidget(m_pPitchSlider, row, 1);
        QObject::connect(m_pPitchSlider, SIGNAL(valueChanged(int)), this, SLOT(pitchChanged(int)));
 
        m_pPitchLine = new QLineEdit;
        m_pPitchLine->setText("0.0");
        pLayout->addWidget(m_pPitchLine, row, 2);
        QObject::connect(m_pPitchLine, SIGNAL(editingFinished()), this, SLOT(pitchEditFinished()));
 
        row++;
 
        // yaw
 
        pLabel = new QLabel("Yaw [degrees]", this);
        pLayout->addWidget(pLabel, row, 0);
 
        m_pYawSlider = new QSlider(Qt::Horizontal, this);
        m_pYawSlider->setMinimum(-1799);
        m_pYawSlider->setMaximum(1800);
        m_pYawSlider->setPageStep(10);
        m_pYawSlider->setValue(0);
        pLayout->addWidget(m_pYawSlider, row, 1);
        QObject::connect(m_pYawSlider, SIGNAL(valueChanged(int)), this, SLOT(yawChanged(int)));
 
        m_pYawLine = new QLineEdit;
        m_pYawLine->setText("0.0");
        pLayout->addWidget(m_pYawLine, row, 2);
        QObject::connect(m_pYawLine, SIGNAL(editingFinished()), this, SLOT(yawEditFinished()));
 
        row++;
 
        // x
 
        pLabel = new QLabel("X [m]", this);
        pLayout->addWidget(pLabel, row, 0);
 
        m_pXSlider = new QSlider(Qt::Horizontal, this);
        m_pXSlider->setMinimum(-10000);
        m_pXSlider->setMaximum(10000);
        m_pXSlider->setPageStep(100);
        m_pXSlider->setValue(0);
        pLayout->addWidget(m_pXSlider, row, 1);
        QObject::connect(m_pXSlider, SIGNAL(valueChanged(int)), this, SLOT(xChanged(int)));
 
        m_pXLine = new QLineEdit;
        m_pXLine->setText("0.00");
        pLayout->addWidget(m_pXLine, row, 2);
        QObject::connect(m_pXLine, SIGNAL(editingFinished()), this, SLOT(xEditFinished()));
 
        row++;
 
        // y
 
        pLabel = new QLabel("Y [m]", this);
        pLayout->addWidget(pLabel, row, 0);
 
        m_pYSlider = new QSlider(Qt::Horizontal, this);
        m_pYSlider->setMinimum(-10000);
        m_pYSlider->setMaximum(10000);
        m_pYSlider->setPageStep(100);
        m_pYSlider->setValue(0);
        pLayout->addWidget(m_pYSlider, row, 1);
        QObject::connect(m_pYSlider, SIGNAL(valueChanged(int)), this, SLOT(yChanged(int)));
 
        m_pYLine = new QLineEdit;
        m_pYLine->setText("0.00");
        pLayout->addWidget(m_pYLine, row, 2);
        QObject::connect(m_pYLine, SIGNAL(editingFinished()), this, SLOT(yEditFinished()));
 
        row++;
 
        // z
 
        pLabel = new QLabel("Z [m]", this);
        pLayout->addWidget(pLabel, row, 0);
 
        m_pZSlider = new QSlider(Qt::Horizontal, this);
        m_pZSlider->setMinimum(-10000);
        m_pZSlider->setMaximum(10000);
        m_pZSlider->setPageStep(100);
        m_pZSlider->setValue(0);
        pLayout->addWidget(m_pZSlider, row, 1);
        QObject::connect(m_pZSlider, SIGNAL(valueChanged(int)), this, SLOT(zChanged(int)));
 
        m_pZLine = new QLineEdit;
        m_pZLine->setText("0.00");
        pLayout->addWidget(m_pZLine, row, 2);
        QObject::connect(m_pZLine, SIGNAL(editingFinished()), this, SLOT(zEditFinished()));
 
        pLayout->setColumnMinimumWidth(1, 200);
        pLayout->setColumnStretch(1, 1);
 
        setLayout(pLayout);
    }
 
    ~cSensorManipulator() override = default;

    void setRollPitchYawRad(tFloat64 fRoll, tFloat64 fPitch, tFloat64 fYaw)
    {
        setRollPitchYawDeg(RAD2DEG(fRoll), RAD2DEG(fPitch), RAD2DEG(fYaw));
    }

    void setRollPitchYawDeg(tFloat64 fRoll, tFloat64 fPitch, tFloat64 fYaw)
    {
        m_pRollSlider->setValue(static_cast<int>(fRoll * 10.0f + 0.5f));
        m_pRollLine->setText(QString("%1").arg(fRoll, 0, 'f', 1));
        m_pPitchSlider->setValue(static_cast<int>(fPitch * 10.0f + 0.5f));
        m_pPitchLine->setText(QString("%1").arg(fPitch, 0, 'f', 1));
        m_pYawSlider->setValue(static_cast<int>(fYaw * 10.0f + 0.5f));
        m_pYawLine->setText(QString("%1").arg(fYaw, 0, 'f', 1));
    }

    void getRollPitchYawRad(tFloat64& fRoll, tFloat64& fPitch, tFloat64& fYaw)
    {
        fRoll = DEG2RAD(m_pRollSlider->value() / 10.0f);
        fPitch = DEG2RAD(m_pPitchSlider->value() / 10.0f);
        fYaw = DEG2RAD(m_pYawSlider->value() / 10.0f);
    }

    void setXYZ(tFloat64 fX, tFloat64 fY, tFloat64 fZ)
    {
        m_pXSlider->setValue(static_cast<int>(fX * 100.0f + 0.5f));
        m_pXLine->setText(QString("%1").arg(fX, 0, 'f', 2));
        m_pYSlider->setValue(static_cast<int>(fY * 100.0f + 0.5f));
        m_pYLine->setText(QString("%1").arg(fY, 0, 'f', 2));
        m_pZSlider->setValue(static_cast<int>(fZ * 100.0f + 0.5f));
        m_pZLine->setText(QString("%1").arg(fZ, 0, 'f', 2));
    }

    void getXYZ(tFloat64& fX, tFloat64& fY, tFloat64& fZ)
    {
        fX = (tFloat64) m_pXSlider->value() / 100.0f;
        fY = (tFloat64) m_pYSlider->value() / 100.0f;
        fZ = (tFloat64) m_pZSlider->value() / 100.0f;
    }
 
    void setDelegate(Delegate* deleg, void* userData = nullptr)
    {
        m_pDeleg = deleg;
        m_pUserData = userData;
    }
 
    void* getUserData()
    {
        return m_pUserData;
    }
 
public slots:
    void rollChanged(int value)
    {
        m_pRollLine->setText(QString("%1").arg(static_cast<float>(value / 10.0f), 0, 'f', 1));
        if (m_pDeleg)
        {
            m_pDeleg->ValuesChangedInManipulator(this);
        }
    }
 
    void rollEditFinished()
    {
        const QString& str = m_pRollLine->text();
        bool ok;
        int val = str.toInt(&ok);
        if (ok)
            m_pRollSlider->setValue(static_cast<int>(val * 10.0f + 0.5f));
        if (m_pDeleg)
        {
            m_pDeleg->ValuesChangedInManipulator(this);
        }
    }
 
    void pitchChanged(int value)
    {
        m_pPitchLine->setText(QString("%1").arg((tFloat64) value / 10.0f, 0, 'f', 1));
        if (m_pDeleg)
        {
            m_pDeleg->ValuesChangedInManipulator(this);
        }
    };
 
    void pitchEditFinished()
    {
        const QString& str = m_pPitchLine->text();
        bool ok;
        int val = str.toInt(&ok);
 
        if (ok)
        {
            m_pPitchSlider->setValue(static_cast<int>(val * 10.0f + 0.5f));
        }
 
        if (m_pDeleg)
        {
            m_pDeleg->ValuesChangedInManipulator(this);
        }
    };
 
    void yawChanged(int value)
    {
        m_pYawLine->setText(QString("%1").arg((tFloat64) value / 10.0f, 0, 'f', 1));
        if (m_pDeleg)
        {
            m_pDeleg->ValuesChangedInManipulator(this);
        }
    };
 
    void yawEditFinished()
    {
        const QString& str = m_pYawLine->text();
        bool ok;
        int val = str.toInt(&ok);
 
        if (ok)
        {
            m_pYawSlider->setValue(static_cast<int>(val * 10.0f + 0.5f));
        }
 
        if (m_pDeleg)
        {
            m_pDeleg->ValuesChangedInManipulator(this);
        }
    };
 
    void xChanged(int value)
    {
        m_pXLine->setText(QString("%1").arg((tFloat64) value / 100.0f, 0, 'f', 2));
        if (m_pDeleg)
        {
            m_pDeleg->ValuesChangedInManipulator(this);
        }
    };
 
    void xEditFinished()
    {
        const QString& str = m_pXLine->text();
        bool ok;
        tFloat64 val = str.toDouble(&ok);
 
        if (ok)
        {
            m_pXSlider->setValue(static_cast<int>(val * 100.0f + 0.5f));
        }
 
        if (m_pDeleg)
        {
            m_pDeleg->ValuesChangedInManipulator(this);
        }
    };
 
    void yChanged(int value)
    {
        m_pYLine->setText(QString("%1").arg((tFloat64) value / 100.0f, 0, 'f', 2));
        if (m_pDeleg)
        {
            m_pDeleg->ValuesChangedInManipulator(this);
        }
    };
 
    void yEditFinished()
    {
        const QString& str = m_pYLine->text();
        bool ok;
        tFloat64 val = str.toDouble(&ok);
 
        if (ok)
        {
            m_pYSlider->setValue(static_cast<int>(val * 100.0f + 0.5f));
        }
 
        if (m_pDeleg)
        {
            m_pDeleg->ValuesChangedInManipulator(this);
        }
    };
 
    void zChanged(int value)
    {
        m_pZLine->setText(QString("%1").arg((tFloat64) value / 100.0f, 0, 'f', 2));
        if (m_pDeleg)
        {
            m_pDeleg->ValuesChangedInManipulator(this);
        }
    };
 
    void zEditFinished()
    {
        const QString& str = m_pZLine->text();
        bool ok;
        tFloat64 val = str.toDouble(&ok);
 
        if (ok)
        {
            m_pZSlider->setValue(static_cast<int>(val * 100.0f + 0.5f));
        }
 
        if (m_pDeleg)
        {
            m_pDeleg->ValuesChangedInManipulator(this);
        }
    };
 
protected:
    QFrame* m_p6DPoseFrame;
 
    QSlider *m_pRollSlider, *m_pPitchSlider, *m_pYawSlider;
    QSlider *m_pXSlider, *m_pYSlider, *m_pZSlider;
    QLineEdit *m_pRollLine, *m_pPitchLine, *m_pYawLine;
    QLineEdit *m_pXLine, *m_pYLine, *m_pZLine;
 
    Delegate* m_pDeleg = nullptr;
    void* m_pUserData = nullptr;
 
    void closeEvent(QCloseEvent* event) override
    {
        // instead of closing the window, we listen to the event and catch it
        // to only hide the window so we can show and hide it as often as we want to
        hide();
        event->ignore();
    }
};
 
} // namespace endor

using endor::cSensorManipulator;
 
} // namespace mixinlib
 
} // namespace disptb
 
} // namespace adtf