AronTreeWidgetConverter.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 <string>
 
// base class
#include "AronTreeWidgetConverter.h"
 
// armarx
#include <SimoxUtility/algorithm/string.h>
 
#include <ArmarXCore/core/logging/Logging.h>
 
#include "RobotAPI/libraries/aron/core/data/variant/All.h"
 
// qt
#include <QTreeWidgetItem>
 
#include "../widgets/EditMatrixWidget.h"
#include "../widgets/IntEnumWidget.h"
#include "../widgets/QuaternionWidget.h"
 
namespace armarx::skills::gui
{
    bool
    AronTreeWidgetConverterVisitor::isConversionSuccessful()
    {
        return !isDirectError && !hasTransitiveError;
    }
 
    bool
    AronTreeWidgetConverterVisitor::onlyChildFailedConversion()
    {
        return hasTransitiveError;
    }
 
    bool
    AronTreeWidgetConverterVisitor::hasDirectError() const
    {
        return isDirectError;
    }
 
    void
    AronTreeWidgetConverterVisitor::handleErrors(AronTreeWidgetConverterVisitor childV,
                                                 bool ownFault)
    {
        ARMARX_TRACE;
        isDirectError |= ownFault;
        hasTransitiveError |= childV.isDirectError || childV.hasTransitiveError;
 
        auto* aronItem = AronTreeWidgetItem::DynamicCast(parentItem->child(index));
        ARMARX_CHECK(aronItem);
        aronItem->setValueErrorState(isDirectError, hasTransitiveError);
    }
 
    void
    AronTreeWidgetConverterVisitor::handleErrors(bool ownFault)
    {
 
        ARMARX_TRACE;
        isDirectError = ownFault;
        auto* aronItem = AronTreeWidgetItem::DynamicCast(parentItem->child(index));
        ARMARX_CHECK(aronItem);
        aronItem->setValueErrorState(isDirectError, false);
    }
 
    void
    AronTreeWidgetConverterVisitor::visitAronVariant(const aron::type::ObjectPtr& i)
    {
 
        ARMARX_TRACE;
        auto createdAronDict = std::make_shared<aron::data::Dict>(i->getPath());
        createdAron = createdAronDict;
        QTreeWidgetItem* el = parentItem->child(index);
 
        if (i->getMaybe() != armarx::aron::type::Maybe::NONE)
        {
            // its a maybetype. We have to check the state
            if (el->checkState(2) == Qt::CheckState::Unchecked)
            {
                createdAron = nullptr;
                return;
            }
        }
 
        unsigned int x = 0;
        for (const auto& [key, value] : i->getMemberTypes())
        {
            ARMARX_TRACE;
            AronTreeWidgetConverterVisitor v(el, x++);
            aron::type::visit(v, value);
 
            handleErrors(v);
            if (v.isConversionSuccessful())
            {
                createdAronDict->addElement(key, v.createdAron);
            }
        }
    }
 
    void
    AronTreeWidgetConverterVisitor::visitAronVariant(const aron::type::DictPtr& i)
    {
 
        ARMARX_TRACE;
        auto createdAronDict = std::make_shared<aron::data::Dict>(i->getPath());
        createdAron = createdAronDict;
        QTreeWidgetItem* el = parentItem->child(index);
 
        if (i->getMaybe() != armarx::aron::type::Maybe::NONE)
        {
            // its a maybetype. We have to check the state
            if (el->checkState(2) == Qt::CheckState::Unchecked)
            {
                createdAron = nullptr;
                return;
            }
        }
 
        for (int x = 0; x < el->childCount(); ++x)
        {
            auto it = el->child(x);
            AronTreeWidgetConverterVisitor v(el, x);
            aron::type::visit(v, i->getAcceptedType());
            auto key = it->text(0).toStdString();
            // TODO: handle key errors more elegantly / separately, fine for now
            handleErrors(v, createdAronDict->hasElement(key));
            if (v.createdAron && v.isConversionSuccessful() && !createdAronDict->hasElement(key))
            {
                createdAronDict->addElement(key, v.createdAron);
            }
        }
    }
 
    void
    AronTreeWidgetConverterVisitor::visitAronVariant(const aron::type::ListPtr& i)
    {
 
        ARMARX_TRACE;
        auto createdAronList = std::make_shared<aron::data::List>(i->getPath());
        createdAron = createdAronList;
        auto* el = parentItem->child(index);
 
        if (i->getMaybe() != armarx::aron::type::Maybe::NONE)
        {
            // its a maybetype. We have to check the state
            if (el->checkState(2) == Qt::CheckState::Unchecked)
            {
                createdAron = nullptr;
                return;
            }
        }
 
        auto childrenTypes = i->getChildren();
        ARMARX_CHECK(childrenTypes.size() == 1);
        for (int j = 0; j < el->childCount(); ++j)
        {
            AronTreeWidgetConverterVisitor convVisitor(el, j);
            aron::type::visit(convVisitor, childrenTypes[0]);
            handleErrors(convVisitor);
 
            if (convVisitor.createdAron && convVisitor.isConversionSuccessful())
            {
                createdAronList->addElement(convVisitor.createdAron);
            }
        }
    }
 
    void
    AronTreeWidgetConverterVisitor::visitAronVariant(const aron::type::PairPtr& i)
    {
 
        ARMARX_TRACE;
        auto createdAronPair = std::make_shared<aron::data::List>(i->getPath());
        createdAron = createdAronPair;
        auto* el = parentItem->child(index);
 
        if (i->getMaybe() != armarx::aron::type::Maybe::NONE)
        {
            // its a maybetype. We have to check the state
            if (el->checkState(2) == Qt::CheckState::Unchecked)
            {
                createdAron = nullptr;
                return;
            }
        }
 
        for (int j = 0; j < 2; ++j)
        {
            AronTreeWidgetConverterVisitor convVisitor(el, j);
            handleErrors(convVisitor);
            if (convVisitor.createdAron && convVisitor.isConversionSuccessful())
            {
                createdAronPair->addElement(convVisitor.createdAron);
            }
        }
    }
 
    void
    AronTreeWidgetConverterVisitor::visitAronVariant(const aron::type::TuplePtr& i)
    {
 
        ARMARX_TRACE;
        auto createdAronList = std::make_shared<aron::data::List>(i->getPath());
        createdAron = createdAronList;
        QTreeWidgetItem* el = parentItem->child(index);
 
        if (i->getMaybe() != armarx::aron::type::Maybe::NONE)
        {
            // its a maybetype. We have to check the state
            if (el->checkState(2) == Qt::CheckState::Unchecked)
            {
                createdAron = nullptr;
                return;
            }
        }
 
        for (int x = 0; x < el->childCount(); ++x)
        {
            auto* it = el->child(x);
            AronTreeWidgetConverterVisitor v(it, x);
            aron::type::visit(v, i->getAcceptedType(x));
            handleErrors(v);
 
            if (v.createdAron)
            {
                createdAronList->addElement(v.createdAron);
            }
        }
    }
 
    void
    AronTreeWidgetConverterVisitor::visitAronVariant(const aron::type::NDArrayPtr& i)
    {
        ARMARX_TRACE;
        ARMARX_ERROR << "Currently do not support supplying raw NDArrays!";
    }
 
    void
    AronTreeWidgetConverterVisitor::visitAronVariant(const aron::type::MatrixPtr& i)
    {
 
        ARMARX_TRACE;
        auto createdMatrix = std::make_shared<aron::data::NDArray>(i->getPath());
        int dataSize = 0;
        switch (i->getElementType())
        {
            case armarx::aron::type::matrix::UINT8:
            case armarx::aron::type::matrix::INT8:
                dataSize = 1;
                break;
            case armarx::aron::type::matrix::UINT16:
            case armarx::aron::type::matrix::INT16:
                dataSize = 2;
                break;
            case armarx::aron::type::matrix::UINT32:
            case armarx::aron::type::matrix::INT32:
            case armarx::aron::type::matrix::FLOAT32:
                dataSize = 4;
                break;
            case armarx::aron::type::matrix::FLOAT64:
            case armarx::aron::type::matrix::INT64:
                dataSize = 8;
                break;
        };
 
 
        // UGLY HACK: FIX ME!!!
        switch (i->getElementType())
        {
            case armarx::aron::type::matrix::UINT8:
                createdMatrix->setType("unsigned char");
                break;
            case armarx::aron::type::matrix::UINT16:
                createdMatrix->setType("unsigned short");
                break;
            case armarx::aron::type::matrix::UINT32:
                createdMatrix->setType("unsigned int");
                break;
            case armarx::aron::type::matrix::INT8:
                createdMatrix->setType("char");
                break;
            case armarx::aron::type::matrix::INT16:
                createdMatrix->setType("short");
                break;
            case armarx::aron::type::matrix::INT32:
                createdMatrix->setType("int");
                break;
            case armarx::aron::type::matrix::FLOAT32:
                createdMatrix->setType("float");
                break;
            case armarx::aron::type::matrix::FLOAT64:
                createdMatrix->setType("double");
                break;
            case armarx::aron::type::matrix::INT64:
                createdMatrix->setType("long");
                break;
        };
 
 
        createdMatrix->setShape({i->getRows(), i->getCols(), dataSize});
        int totalByteSize = i->getRows() * i->getCols() * dataSize;
        createdAron = createdMatrix;
        auto* el = parentItem->child(index);
 
        if (i->getMaybe() != armarx::aron::type::Maybe::NONE)
        {
            // its a maybetype. We have to check the state
            if (el->checkState(2) == Qt::CheckState::Unchecked)
            {
                createdAron = nullptr;
                return;
            }
        }
 
 
        auto* rootWidget = el->treeWidget();
        ARMARX_CHECK(rootWidget);
        auto* widget = rootWidget->itemWidget(el, 1);
        ARMARX_CHECK(rootWidget);
        auto* matrixWidget = EditMatrixWidget::DynamicCastAndCheck(widget);
        ARMARX_CHECK(matrixWidget);
 
        handleErrors(matrixWidget->hasParseErrors());
        if (matrixWidget->hasParseErrors())
        {
            return;
        }
 
 
        // write to aron data
        std::vector<unsigned char> elems;
        elems.reserve(totalByteSize);
        // CAUTION: Raw data has column based storage
        for (size_t col = 0; col < (size_t)i->getCols(); ++col)
        {
            for (size_t row = 0; row < (size_t)i->getRows(); ++row)
            {
                // gets us directly the byte wise format
                auto parsed = matrixWidget->parseElement(row, col);
                // append vector to vector
                elems.insert(elems.end(), parsed.begin(), parsed.end());
            }
        }
        createdMatrix->setData(totalByteSize, elems.data());
    }
 
    void
    AronTreeWidgetConverterVisitor::visitAronVariant(const aron::type::QuaternionPtr& i)
    {
 
        ARMARX_TRACE;
        auto createdQuat = std::make_shared<aron::data::NDArray>(i->getPath());
        createdAron = createdQuat;
        int dataSize = i->getElementType() == aron::type::quaternion::ElementType::FLOAT32 ? 4 : 8;
        createdQuat->setShape({1, 4, dataSize});
        createdQuat->setType(i->getFullName());
        auto* el = parentItem->child(index);
 
        if (i->getMaybe() != armarx::aron::type::Maybe::NONE)
        {
            // its a maybetype. We have to check the state
            if (el->checkState(2) == Qt::CheckState::Unchecked)
            {
                createdAron = nullptr;
                return;
            }
        }
 
        auto* itemWidget = el->treeWidget()->itemWidget(el, 1);
        auto* quatWidget = QuaternionWidget::DynamicCastAndCheck(itemWidget);
 
        // error handling
        handleErrors(quatWidget->hasParseErrors());
        if (quatWidget->hasParseErrors())
        {
            return;
        }
 
        // write to aron data
        auto serialized = quatWidget->parseAllToNDArray();
        if ((int)serialized.size() != dataSize * 4)
        {
            ARMARX_ERROR
                << "serialized quaternions did not return byte sequence of correct length!";
        }
        createdQuat->setData(serialized.size(), serialized.data());
    }
 
    void
    AronTreeWidgetConverterVisitor::visitAronVariant(const aron::type::ImagePtr& i)
    {
        ARMARX_TRACE;
        // TODO
    }
 
    void
    AronTreeWidgetConverterVisitor::visitAronVariant(const aron::type::PointCloudPtr& i)
    {
        ARMARX_TRACE;
        // TODO
    }
 
    void
    AronTreeWidgetConverterVisitor::visitAronVariant(const aron::type::IntEnumPtr& i)
    {
 
        ARMARX_TRACE;
        QTreeWidgetItem* el = parentItem->child(index);
 
        if (i->getMaybe() != armarx::aron::type::Maybe::NONE)
        {
            // its a maybetype. We have to check the state
            if (el->checkState(2) == Qt::CheckState::Unchecked)
            {
                createdAron = nullptr;
                return;
            }
        }
 
        auto* genericWidget = el->treeWidget()->itemWidget(el, 1);
        auto* intEnumWidget = IntEnumWidget::DynamicCastAndCheck(genericWidget);
        if (!intEnumWidget)
        {
            // already reporting error; continue here
            return;
        }
        bool success;
        std::tie(success, createdAron) = intEnumWidget->parseToAron();
 
        handleErrors(!success);
    }
 
    void
    AronTreeWidgetConverterVisitor::visitAronVariant(const aron::type::IntPtr& i)
    {
 
        ARMARX_TRACE;
        auto createdAronInt = std::make_shared<aron::data::Int>(i->getPath());
        createdAron = createdAronInt;
        QTreeWidgetItem* el = parentItem->child(index);
 
        if (i->getMaybe() != armarx::aron::type::Maybe::NONE)
        {
            // its a maybetype. We have to check the state
            if (el->checkState(2) == Qt::CheckState::Unchecked)
            {
                createdAron = nullptr;
                return;
            }
        }
 
        std::string str = el->text(1).toStdString();
        if (str.empty())
        {
            createdAronInt->setValue(0);
            return;
        }
        try
        {
            int val = simox::alg::to_<int>(str);
            createdAronInt->setValue(val);
        }
        catch (const simox::error::SimoxError& err)
        {
            handleErrors();
            ARMARX_VERBOSE << "Conversion from String to Int failed. Error:\"" << err.what()
                           << "\"";
            return;
        }
        handleErrors(false);
    }
 
    void
    AronTreeWidgetConverterVisitor::visitAronVariant(const aron::type::LongPtr& i)
    {
 
        ARMARX_TRACE;
        auto createdAronLong = std::make_shared<aron::data::Long>(i->getPath());
        createdAron = createdAronLong;
        QTreeWidgetItem* el = parentItem->child(index);
 
        if (i->getMaybe() != armarx::aron::type::Maybe::NONE)
        {
            // its a maybetype. We have to check the state
            if (el->checkState(2) == Qt::CheckState::Unchecked)
            {
                createdAron = nullptr;
                return;
            }
        }
 
        std::string str = el->text(1).toStdString();
        if (str.empty())
        {
            //TODO: similar behaviour for rest?
            str = el->text(3).toStdString();
        }
        try
        {
            createdAronLong->setValue(simox::alg::to_<long>(str));
        }
        catch (const simox::error::SimoxError& err)
        {
            handleErrors();
            ARMARX_VERBOSE << "Conversion from String to Long failed. Error:\"" << err.what()
                           << "\"";
            return;
        }
        handleErrors(false);
    }
 
    void
    AronTreeWidgetConverterVisitor::visitAronVariant(const aron::type::FloatPtr& i)
    {
 
        ARMARX_TRACE;
        auto createdAronFloat = std::make_shared<aron::data::Float>(i->getPath());
        createdAron = createdAronFloat;
        QTreeWidgetItem* el = parentItem->child(index);
 
        if (i->getMaybe() != armarx::aron::type::Maybe::NONE)
        {
            // its a maybetype. We have to check the state
            if (el->checkState(2) == Qt::CheckState::Unchecked)
            {
                createdAron = nullptr;
                return;
            }
        }
 
        std::string str = el->text(1).toStdString();
        if (str.empty())
        {
            str = el->text(3).toStdString();
        }
        try
        {
            createdAronFloat->setValue(simox::alg::to_<float>(str));
        }
        catch (const simox::error::SimoxError& err)
        {
            handleErrors();
            ARMARX_VERBOSE << "Conversion from String to Float failed. Error:\"" << err.what()
                           << "\"";
            return;
        }
        handleErrors(false);
    }
 
    void
    AronTreeWidgetConverterVisitor::visitAronVariant(const aron::type::DoublePtr& i)
    {
 
        ARMARX_TRACE;
        auto createdAronDouble = std::make_shared<aron::data::Double>(i->getPath());
        createdAron = createdAronDouble;
        QTreeWidgetItem* el = parentItem->child(index);
 
        if (i->getMaybe() != armarx::aron::type::Maybe::NONE)
        {
            // its a maybetype. We have to check the state
            if (el->checkState(2) == Qt::CheckState::Unchecked)
            {
                createdAron = nullptr;
                return;
            }
        }
 
        std::string str = el->text(1).toStdString();
        if (str.empty())
        {
            str = el->text(3).toStdString();
        }
        try
        {
            createdAronDouble->setValue(simox::alg::to_<double>(str));
        }
        catch (const simox::error::SimoxError& err)
        {
            handleErrors();
            ARMARX_VERBOSE << "Conversion from String to Double failed. Error:\"" << err.what()
                           << "\"";
            return;
        }
        handleErrors(false);
    }
 
    void
    AronTreeWidgetConverterVisitor::visitAronVariant(const aron::type::BoolPtr& i)
    {
 
        ARMARX_TRACE;
        auto createdAronBool = std::make_shared<aron::data::Bool>(i->getPath());
        createdAron = createdAronBool;
        QTreeWidgetItem* el = parentItem->child(index);
 
        if (i->getMaybe() != armarx::aron::type::Maybe::NONE)
        {
            // its a maybetype. We have to check the state
            if (el->checkState(2) == Qt::CheckState::Unchecked)
            {
                createdAron = nullptr;
                return;
            }
        }
 
        std::string str = el->text(1).toStdString();
        if (str.empty())
        {
            str = el->text(3).toStdString();
        }
        try
        {
            createdAronBool->setValue(simox::alg::to_<bool>(str));
        }
        catch (const simox::error::SimoxError& err)
        {
            handleErrors();
            ARMARX_VERBOSE << "Conversion from String to Bool failed. Error:\"" << err.what()
                           << "\"";
            return;
        }
        handleErrors(false);
    }
 
    void
    AronTreeWidgetConverterVisitor::visitAronVariant(const aron::type::StringPtr& i)
    {
 
        ARMARX_TRACE;
        auto createdAronString = std::make_shared<aron::data::String>(i->getPath());
        createdAron = createdAronString;
        QTreeWidgetItem* el = parentItem->child(index);
 
        if (el == nullptr)
        {
            return;
        }
 
        if (i->getMaybe() != armarx::aron::type::Maybe::NONE)
        {
            // its a maybetype. We have to check the state
            if (el->checkState(2) == Qt::CheckState::Unchecked)
            {
                createdAron = nullptr;
                return;
            }
        }
 
        std::string str = el->text(1).toStdString();
        createdAronString->setValue(str);
    }
 
    void
    AronTreeWidgetConverterVisitor::visitUnknown(Input&)
    {
        ARMARX_WARNING_S << "Received an unknown type when trying to convert a skill argument type "
                            "to an aron data object.";
    }
} // namespace armarx::skills::gui