DataDisplayVisitor.cpp

Go to the documentation of this file.

#include "DataDisplayVisitor.h"
 
#include <RobotAPI/libraries/aron/core/data/variant/All.h>
 
namespace armarx::aron
{
 
    std::string
    DataDisplayVisitor::getValue(const data::VariantPtr& n)
    {
        DataDisplayVisitor v;
        data::visit(v, n);
        return v.value.str();
    }
 
    void
    DataDisplayVisitor::visitDict(const data::VariantPtr& n)
    {
        auto x = data::Dict::DynamicCastAndCheck(n);
        value << x->childrenSize() << " items";
    }
 
    void
    DataDisplayVisitor::visitList(const data::VariantPtr& n)
    {
        auto x = data::List::DynamicCastAndCheck(n);
        value << x->childrenSize() << " items";
    }
 
    void
    DataDisplayVisitor::visitBool(const data::VariantPtr& b)
    {
        auto x = data::Bool::DynamicCastAndCheck(b);
        if (x->getValue())
        {
            value << "true";
        }
        else
        {
            value << "false";
        }
    }
 
    void
    DataDisplayVisitor::visitDouble(const data::VariantPtr& n)
    {
        auto x = data::Double::DynamicCastAndCheck(n);
        value << x->getValue();
    }
 
    void
    DataDisplayVisitor::visitFloat(const data::VariantPtr& n)
    {
        auto x = data::Float::DynamicCastAndCheck(n);
        value << x->getValue();
    }
 
    void
    DataDisplayVisitor::visitInt(const data::VariantPtr& n)
    {
        auto x = data::Int::DynamicCastAndCheck(n);
        value << x->getValue();
    }
 
    void
    DataDisplayVisitor::visitLong(const data::VariantPtr& n)
    {
        auto x = data::Long::DynamicCastAndCheck(n);
        value << x->getValue();
    }
 
    void
    DataDisplayVisitor::visitString(const data::VariantPtr& n)
    {
        auto x = data::String::DynamicCastAndCheck(n);
        value << "'" << x->getValue() << "'";
    }
 
    void
    DataDisplayVisitor::visitNDArray(const data::VariantPtr& data)
    {
        auto d = data::NDArray::DynamicCastAndCheck(data);
 
        if (d->getType() == "float")
        {
            setStreamPrecision();
            processMatrix<float>(*d);
        }
        else if (d->getType() == "double")
        {
            setStreamPrecision();
            processMatrix<double>(*d);
        }
        else
        {
            printShape(*d);
        }
    }
 
    void
    DataDisplayVisitor::printShape(const data::NDArray& d)
    {
        value << "shape " << aron::data::NDArray::DimensionsToString(d.getShape()) << ", type '"
              << d.getType() << "'";
    }
 
    template <typename ScalarT>
    void
    DataDisplayVisitor::processMatrix(const data::NDArray& data)
    {
        const int rows = data.getShape().at(0);
        const int cols = data.getShape().at(1);
 
        const Eigen::Map<Eigen::Matrix<ScalarT, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>> m(
            reinterpret_cast<ScalarT*>(data.getData()), rows, cols);
 
        const int maxRows = 10;
        const int maxCols = 10;
 
        if (cols > maxCols)
        {
            printShape(data);
        }
        else if (rows > maxRows)
        {
            int shownRows = 2;
 
            value << "(";
            printShape(data);
            value << ")\n"
                  << m.block(0, 0, shownRows, cols) << "\n...\n"
                  << m.block(rows - shownRows, 0, shownRows, cols);
        }
        else
        {
            value << m.format(eigenIof);
        }
    }
 
 
} // namespace armarx::aron