AronTreeWidgetSetter.cpp

Go to the documentation of this file.

/*
 * This file is part of ArmarX.
 *
 * ArmarX is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * ArmarX is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * \package    RobotAPI::gui-plugins::SkillManagerMonitorWidgetController
 * \author     Raphael Grimm ( raphael dot grimm at kit dot edu )
 * \date       2020
 * \copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
#include "AronTreeWidgetSetter.h"
 
#include <string>
 
#include "../ListDictHelper.h"
#include "../widgets/EditMatrixWidget.h"
#include "../widgets/IntEnumWidget.h"
#include "../widgets/QuaternionWidget.h"
#include "AronTreeWidgetContextMenu.h"
#include "AronTreeWidgetCreator.h"
 
template <typename T>
std::string
usString(T number, size_t precision = 3)
{
 
    std::stringstream ss;
    const char* locale = "C";
    ss.imbue(std::locale(locale));
    ss << std::fixed << std::setprecision(precision) << number;
 
    return ss.str();
}
 
//visitors
namespace armarx::skills::gui
{
    bool
    AronTreeWidgetSetterVisitor::checkTreeWidgetItemForSimilarName(const std::string& name) const
    {
        QTreeWidgetItem* el = parentItem->child(index);
 
        // do not check attribute name, if the element is part of a list or map
        auto* castedThis = AronTreeWidgetItem::DynamicCast(el->parent());
        if (castedThis)
        {
            auto descr = castedThis->aronType->getDescriptor();
            if (descr == aron::type::Descriptor::LIST || descr == aron::type::Descriptor::DICT)
            {
                return true;
            }
        }
        std::string n = el->text(0).toStdString();
        if (name != n)
        {
            ARMARX_WARNING_S << "Could not set a tree widget value for the element with key '"
                             << name << "' because it is different from the expected name '" << n
                             << "'.";
            return false;
        }
        return true;
    }
 
    void
    AronTreeWidgetSetterVisitor::adjustNumberOfChildren(AronTreeWidgetItem* parent,
                                                        size_t numChildren)
    {
        if (((size_t)parent->childCount()) < numChildren)
        {
            // The type to create must be the only child of the current aron type
            ARMARX_CHECK_EQUAL(parent->aronType->childrenSize(), 1);
            size_t childrenToAdd = numChildren - parent->childCount();
            for (size_t j = 0; j < childrenToAdd; ++j)
            {
                AronTreeWidgetCreatorVisitor childCreator(parent);
                aron::type::visit(childCreator, parent->aronType->getChildren()[0]);
                ARMARX_CHECK_NOT_NULL(childCreator.createdQWidgetItem);
            }
        }
        else if ((size_t)parent->childCount() > numChildren)
        {
            size_t numChilds = (size_t)parent->childCount() - numChildren;
            // pop the last child
            for (size_t j = 0; j < numChilds; ++j)
            {
                parent->removeChild(parent->child(parent->childCount() - 1));
            }
        }
    }
 
    void
    AronTreeWidgetSetterVisitor::visitAronVariant(const aron::data::DictPtr& i)
    {
 
        // either it is the root or it has a name
        if (i->getPath().size() == 0 ||
            checkTreeWidgetItemForSimilarName(i->getPath().getLastElement()))
        {
            AronTreeWidgetItem* el = AronTreeWidgetItem::DynamicCast(parentItem->child(index));
            auto* aronTreeWidget = AronTreeWidgetItem::DynamicCastAndCheck(el);
            // allocate enough child items
            adjustNumberOfChildren(aronTreeWidget, i->childrenSize());
 
            // write child values
            unsigned int x = 0;
            for (const auto& [key, value] : i->getElements())
            {
                el->child(x)->setText(0, {key.c_str()});
 
                AronTreeWidgetSetterVisitor v(el, x++);
                aron::data::visit(v, value);
            }
 
            if (el->aronType && el->aronType->getMaybe() != armarx::aron::type::Maybe::NONE)
            {
                el->setCheckState(2, Qt::CheckState::Checked);
            }
        }
    }
 
    void
    AronTreeWidgetSetterVisitor::visitAronVariant(const aron::data::ListPtr& i)
    {
 
        if (checkTreeWidgetItemForSimilarName(i->getPath().getLastElement()))
        {
            AronTreeWidgetItem* el = AronTreeWidgetItem::DynamicCast(parentItem->child(index));
            auto* aronTreeWidget = AronTreeWidgetItem::DynamicCastAndCheck(el);
            adjustNumberOfChildren(aronTreeWidget, i->childrenSize());
 
            unsigned int x = 0;
            for (const auto& value : i->getElements())
            {
                AronTreeWidgetSetterVisitor v(el, x);
                aron::data::visit(v, value);
                auto* currChild = el->child(x);
                std::string listNum = usString(x);
                currChild->setText(0, listNum.c_str());
 
                ++x;
            }
            // This displays the number of children also when the list is collapsed
            QString numElemsText = misc::generateNumElementsText(i->getElements().size());
            aronTreeWidget->setText(1, numElemsText);
            // set italic
            auto currFont = aronTreeWidget->font(1);
            currFont.setItalic(true);
            aronTreeWidget->setFont(1, currFont);
 
            if (el->aronType && el->aronType->getMaybe() != armarx::aron::type::Maybe::NONE)
            {
                el->setCheckState(2, Qt::CheckState::Checked);
            }
        }
    }
 
    void
    visitMatrix(EditMatrixWidget* matrixWidget,
                const std::shared_ptr<armarx::aron::type::Matrix>& matrixType,
                const aron::data::NDArrayPtr& arr)
    {
 
        auto elemType = matrixType->getElementType();
        auto* rawData = arr->getData();
        // string can convert any item
        auto toString = [elemType, rawData](size_t elementNr) -> std::string
        {
            switch (elemType)
            {
                case aron::type::matrix::ElementType::FLOAT32:
                {
                    static_assert(sizeof(float) == 4);
                    float* interpreted = reinterpret_cast<float*>(rawData);
                    float laundered = std::launder(interpreted)[elementNr];
                    return usString<float>(laundered);
                }
                case aron::type::matrix::ElementType::FLOAT64:
                {
                    static_assert(sizeof(double) == 8);
                    double* interpreted = reinterpret_cast<double*>(rawData);
                    float laundered = std::launder(interpreted)[elementNr];
                    return usString<double>(laundered);
                }
                case aron::type::matrix::ElementType::UINT8:
                {
                    auto* interpreted = reinterpret_cast<uint8_t*>(rawData);
                    auto laudered = std::launder(interpreted)[elementNr];
                    return usString<>(laudered);
                }
                case aron::type::matrix::ElementType::UINT16:
                {
                    auto* interpreted = reinterpret_cast<uint16_t*>(rawData);
                    auto laudered = std::launder(interpreted)[elementNr];
                    return usString<>(laudered);
                }
                case aron::type::matrix::ElementType::UINT32:
                {
                    auto* interpreted = reinterpret_cast<uint32_t*>(rawData);
                    auto laudered = std::launder(interpreted)[elementNr];
                    return usString<>(laudered);
                }
                case aron::type::matrix::ElementType::INT8:
                {
                    auto* interpreted = reinterpret_cast<int8_t*>(rawData);
                    auto laudered = std::launder(interpreted)[elementNr];
                    return usString<>(laudered);
                }
                case aron::type::matrix::ElementType::INT16:
                {
                    int16_t* interpreted = reinterpret_cast<int16_t*>(rawData);
                    int16_t laudered = std::launder(interpreted)[elementNr];
                    return usString<int16_t>(laudered);
                }
                case aron::type::matrix::ElementType::INT32:
                {
                    int32_t* interpreted = reinterpret_cast<int32_t*>(rawData);
                    int32_t laudered = std::launder(interpreted)[elementNr];
                    return usString<int32_t>(laudered);
                }
                case aron::type::matrix::ElementType::INT64:
                {
                    int64_t* interpreted = reinterpret_cast<int64_t*>(rawData);
                    int64_t laudered = std::launder(interpreted)[elementNr];
                    return usString<int64_t>(laudered);
                }
            }
            return "Error!";
        };
 
 
        for (size_t row = 0; (int)row < matrixType->getRows(); ++row)
        {
            for (size_t col = 0; (int)col < matrixType->getCols(); ++col)
            {
                matrixWidget->setText(row, col, toString(row * matrixType->getCols() + col));
            }
        }
    }
 
    void
    visitQuaternion(QuaternionWidget* quatWidget,
                    std::shared_ptr<armarx::aron::type::Quaternion>& quatType,
                    const aron::data::NDArrayPtr& arr)
    {
 
        auto elemType = quatType->getElementType();
        auto rawData = arr->getData();
        auto shape = arr->getShape();
        // string can convert any item
        auto toString = [elemType, rawData](size_t elementNr) -> std::string
        {
            switch (elemType)
            {
                case aron::type::quaternion::ElementType::FLOAT32:
                {
                    static_assert(sizeof(float) == 4);
                    float* interpreted = reinterpret_cast<float*>(rawData);
                    float laundered = std::launder(interpreted)[elementNr];
                    return usString<float>(laundered);
                }
                case aron::type::quaternion::ElementType::FLOAT64:
                {
                    static_assert(sizeof(double) == 8);
                    double* interpreted = reinterpret_cast<double*>(rawData);
 
                    float laundered = std::launder(interpreted)[elementNr];
                    return usString<double>(laundered);
                }
            }
            return "Error!";
        };
        for (size_t i = 0; i < 4; ++i)
        {
            quatWidget->setText((QuaternionWidget::QuaternionComponents)i, toString(i));
        }
    }
 
    void
    AronTreeWidgetSetterVisitor::visitAronVariant(const aron::data::NDArrayPtr& arr)
    {
 
        // Matrices are handled as NDArray. Raw ndarrays cannot be created currently
        auto* el = AronTreeWidgetItem::DynamicCast(parentItem->child(index));
        ARMARX_CHECK(el);
 
        auto matrixCast = aron::type::Matrix::DynamicCast(el->aronType);
        auto quaternionCast = aron::type::Quaternion::DynamicCast(el->aronType);
 
        auto* rootWidget = el->treeWidget();
        ARMARX_CHECK(rootWidget);
        auto* matrixWidget = EditMatrixWidget::DynamicCast(rootWidget->itemWidget(el, 1));
        auto* quaternionWidget = QuaternionWidget::DynamicCast(rootWidget->itemWidget(el, 1));
 
        if (matrixCast && matrixWidget)
        {
            visitMatrix(matrixWidget, matrixCast, arr);
        }
        else if (quaternionCast && quaternionWidget)
        {
            visitQuaternion(quaternionWidget, quaternionCast, arr);
        }
        else
        {
            ARMARX_ERROR
                << "we do not support raw NDArrays. Ask Fabian Peller for more information.";
        }
 
        if (el->aronType && el->aronType->getMaybe() != armarx::aron::type::Maybe::NONE)
        {
            el->setCheckState(2, Qt::CheckState::Checked);
        }
    }
 
    void
    AronTreeWidgetSetterVisitor::visitAronVariant(const aron::data::IntPtr& i)
    {
 
        if (checkTreeWidgetItemForSimilarName(i->getPath().getLastElement()))
        {
            AronTreeWidgetItem* el = AronTreeWidgetItem::DynamicCast(parentItem->child(index));
            auto* enumWidget = IntEnumWidget::DynamicCast(el->treeWidget()->itemWidget(el, 1));
            auto newText = QString::fromStdString(usString<int>(i->getValue()));
            if (enumWidget)
            {
                // Its an IntEnum! -> Ask the custom widget
                enumWidget->setText(newText);
            }
            else
            {
                // Its just an int. -> do the QTreeWidgetItem call
                el->setText(1, newText);
            }
 
            if (el->aronType && el->aronType->getMaybe() != armarx::aron::type::Maybe::NONE)
            {
                el->setCheckState(2, Qt::CheckState::Checked);
            }
        }
    }
 
    void
    AronTreeWidgetSetterVisitor::visitAronVariant(const aron::data::LongPtr& i)
    {
 
        if (checkTreeWidgetItemForSimilarName(i->getPath().getLastElement()))
        {
            AronTreeWidgetItem* el = AronTreeWidgetItem::DynamicCast(parentItem->child(index));
            el->setText(1, QString::fromStdString(usString<long>(i->getValue())));
 
            if (el->aronType && el->aronType->getMaybe() != armarx::aron::type::Maybe::NONE)
            {
                el->setCheckState(2, Qt::CheckState::Checked);
            }
        }
    }
 
    void
    AronTreeWidgetSetterVisitor::visitAronVariant(const aron::data::FloatPtr& i)
    {
        if (checkTreeWidgetItemForSimilarName(i->getPath().getLastElement()))
        {
            AronTreeWidgetItem* el = AronTreeWidgetItem::DynamicCast(parentItem->child(index));
            std::string repr = usString<float>(i->getValue());
            QString qstr = QString::fromStdString(repr);
            el->setText(1, qstr);
            if (el->aronType && el->aronType->getMaybe() != armarx::aron::type::Maybe::NONE)
            {
                el->setCheckState(2, Qt::CheckState::Checked);
            }
        }
    }
 
    void
    AronTreeWidgetSetterVisitor::visitAronVariant(const aron::data::DoublePtr& i)
    {
 
        if (checkTreeWidgetItemForSimilarName(i->getPath().getLastElement()))
        {
            AronTreeWidgetItem* el = AronTreeWidgetItem::DynamicCast(parentItem->child(index));
            el->setText(1, QString::fromStdString(usString<double>(i->getValue())));
 
            if (el->aronType && el->aronType->getMaybe() != armarx::aron::type::Maybe::NONE)
            {
                el->setCheckState(2, Qt::CheckState::Checked);
            }
        }
    }
 
    void
    AronTreeWidgetSetterVisitor::visitAronVariant(const aron::data::BoolPtr& i)
    {
 
        if (checkTreeWidgetItemForSimilarName(i->getPath().getLastElement()))
        {
            AronTreeWidgetItem* el = AronTreeWidgetItem::DynamicCast(parentItem->child(index));
            el->setText(1, QString::fromStdString(usString<bool>(i->getValue())));
 
            if (el->aronType && el->aronType->getMaybe() != armarx::aron::type::Maybe::NONE)
            {
                el->setCheckState(2, Qt::CheckState::Checked);
            }
        }
    }
 
    void
    AronTreeWidgetSetterVisitor::visitAronVariant(const aron::data::StringPtr& i)
    {
 
        if (checkTreeWidgetItemForSimilarName(i->getPath().getLastElement()))
        {
            AronTreeWidgetItem* el = AronTreeWidgetItem::DynamicCast(parentItem->child(index));
            el->setText(1, QString::fromStdString(i->getValue()));
 
            if (el->aronType && el->aronType->getMaybe() != armarx::aron::type::Maybe::NONE)
            {
                el->setCheckState(2, Qt::CheckState::Checked);
            }
        }
    }
 
    void
    AronTreeWidgetSetterVisitor::visitUnknown(Input&)
    {
        ARMARX_WARNING_S << "Received an unknown type when trying to set a skill argument type "
                            "from an aron data object.";
    }
} // namespace armarx::skills::gui