QuaternionWidget.cpp

Go to the documentation of this file.

#include "QuaternionWidget.h"
 
#include <QHBoxLayout>
#include <QLabel>
#include <QLineEdit>
 
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
 
#include <RobotAPI/interface/aron/Aron.h>
 
#include "../../ColorPalettes.h"
#include "NDArrayHelper.h"
 
namespace armarx
{
 
    QuaternionWidget*
    QuaternionWidget::DynamicCast(QWidget* elem)
    {
        return dynamic_cast<QuaternionWidget*>(elem);
    }
 
    QuaternionWidget*
    QuaternionWidget::DynamicCastAndCheck(QWidget* elem)
    {
        if (!elem)
        {
            return nullptr;
        }
        auto* casted = DynamicCast(elem);
        ARMARX_CHECK_NOT_NULL(casted);
        return casted;
    }
 
    void
    QuaternionWidget::setText(QuaternionComponents col, const std::string& str)
    {
        size_t idx = (size_t)col;
        xyzw_components.at(idx)->setText(str.c_str());
        highlightUnparsableEntries();
    }
 
    bool
    QuaternionWidget::hasParseErrors()
    {
        return parseErrors;
    }
 
    armarx::QuaternionWidget::QuaternionWidget(aron::type::quaternion::ElementType elType,
                                               QTreeWidgetItem* currentItem) :
        CustomWidget(currentItem), element_type(elType)
    {
        auto outerLayout = new QHBoxLayout();
        auto labelCol1 = new QVBoxLayout();
        auto labelCol2 = new QVBoxLayout();
        auto xzEdit = new QVBoxLayout();
        auto ywEdit = new QVBoxLayout();
 
        outerLayout->addLayout(labelCol1);
        outerLayout->addLayout(xzEdit);
        outerLayout->addLayout(labelCol2);
        outerLayout->addLayout(ywEdit);
 
        xyzw_components.reserve(4);
        for (size_t i = 0; i < 4; ++i)
        {
            xyzw_components.push_back(new QLineEdit());
        }
 
        // Tabbing order >> Viewing order. Thats why the indeces are a bit switched
        labelCol1->addWidget(new QLabel("x"));
        xzEdit->addWidget(xyzw_components.at(0));
 
        labelCol2->addWidget(new QLabel("z"));
        ywEdit->addWidget(xyzw_components.at(2));
 
        labelCol1->addWidget(new QLabel("y"));
        xzEdit->addWidget(xyzw_components.at(1));
 
        labelCol2->addWidget(new QLabel("w"));
        ywEdit->addWidget(xyzw_components.at(3));
 
        for (const auto& el : xyzw_components)
        {
            ARMARX_CHECK(
                connect(el, SIGNAL(editingFinished()), this, SLOT(quaternionElementChanged())));
        }
 
        setLayout(outerLayout);
        highlightUnparsableEntries();
    }
 
    void
    QuaternionWidget::highlightUnparsableEntries()
    {
        parseErrors = false;
        for (size_t i = 0; i < 4; ++i)
        {
            bool ok = false;
            switch (element_type)
            {
                case armarx::aron::type::quaternion::FLOAT32:
                {
                    float flt;
                    std::tie(ok, flt) = parseQuatVals<float>((QuaternionComponents)i);
                    break;
                }
                case armarx::aron::type::quaternion::FLOAT64:
                {
                    double dbl;
                    std::tie(ok, dbl) = parseQuatVals<double>((QuaternionComponents)i);
                    break;
                }
            }
            if (ok)
            {
                xyzw_components.at(i)->setPalette(gui_color_palette::getNormalPalette());
            }
            else
            {
                xyzw_components.at(i)->setPalette(gui_color_palette::getErrorPalette());
                parseErrors = true;
            }
        }
    }
 
    std::vector<unsigned char>
    QuaternionWidget::parseAllToNDArray()
    {
        std::vector<unsigned char> res;
        bool success = true;
        if (element_type == aron::type::quaternion::FLOAT32)
        {
            res.reserve(16);
            for (size_t i = 0; i < 4; ++i)
            {
                auto bytevec =
                    NDArrayHelper::toByteVector<float>(xyzw_components.at(i)->text().toStdString());
                success &= !bytevec.empty();
                res.insert(res.end(), bytevec.begin(), bytevec.end());
            }
        }
        else
        {
            res.reserve(32);
            for (size_t i = 0; i < 4; ++i)
            {
                auto bytevec = NDArrayHelper::toByteVector<double>(
                    xyzw_components.at(i)->text().toStdString());
                success &= !bytevec.empty();
                res.insert(res.end(), bytevec.begin(), bytevec.end());
            }
        }
        return (success) ? res : std::vector<unsigned char>();
    }
 
    void
    QuaternionWidget::quaternionElementChanged()
    {
        CustomWidget::setSupressSignals(true);
        highlightUnparsableEntries();
        CustomWidget::setSupressSignals(false);
        emit CustomWidget::elemChanged(overlayingItem, 1);
    }
} // namespace armarx