Parse json to Eigen

[hei6775]

I need save matrix in eigen to json file. And read it back.
But I don't know how to get it back.
please give me a example.

int main()
{
    MatrixXf a(4,4);
    a << 1.2, 1.4, 1.6, 1.8,
        1.5, 1.7, 1.9, 1.10,
        0.8, 1.2, -0.1, -0.2,
        1.3, 99, 100, 112;}
    // write
    nlohmann::json b;
    std::vector<uint8_t> output_vector;
    b["hello"] = a;
    outFile.open("test.json", std::ios::out | std::ios::binary);
    nlohmann::json::to_cbor(b,output_vector);
    outFile.write((char*)output_vector.data(), output_vector.size());

    // read
    std::ifstream inFile("test.json",std::ios::in | std::ios::binary);
    std::vector<uint8_t> input_vector(
        (std::istreambuf_iterator<char>(inFile)),
        std::istreambuf_iterator<char>());
    nlohmann::json outJson = nlohmann::json::from_cbor(input_vector);

    // then how to convert it to MatrixXf

And, I do some work but I don't know whether it is right. to_json from_json

namespace Eigen
{

template< typename ScalarType, int rows, int cols >
void to_json( nlohmann::json& jsonObject, const Matrix< ScalarType, rows, cols >& matrix )
{
    for ( int r = 0; r < matrix.rows( ); ++r )
    {
        nlohmann::json jsonArray;
        for ( int c = 0; c < matrix.cols( ); ++c )
        {
            jsonArray.push_back( matrix( r, c ) );
        }
        jsonObject.push_back( jsonArray );
    }
}

template< typename ScalarType, int rows, int cols >
void from_json( const nlohmann::json& jsonObject, Matrix< ScalarType, rows, cols >& matrix )
{
    nlohmann::json jsonArray;
    if ( jsonObject.is_array( ) )
    {
        if ( jsonObject.empty( ) )
        {
            return;
        }
        jsonArray = jsonObject;
    }
    else if ( jsonObject.is_number( ) )
    {
        jsonArray.push_back( jsonObject );
    }
    else
    {
        throw nlohmann::detail::type_error::create( 0, "" );
    }

    nlohmann::json jsonArrayOfArrays;
    if ( jsonArray.front( ).is_array( ) )  // provided matrix
    {
        jsonArrayOfArrays = jsonArray;
    }
    else  // provided vector
    {
        if ( rows == 1 )  // expected row vector
        {
            jsonArrayOfArrays.push_back( jsonArray );
        }
        else if ( cols == 1 )  // expected column vector
        {
            for ( unsigned int i = 0; i < jsonArray.size( ); ++i )
            {
                jsonArrayOfArrays.push_back( { jsonArray.at( i ) } );
            }
        }
        else  // expected matrix
        {
            std::cerr << "Expected a matrix, received a vector." << std::endl;
            throw nlohmann::detail::type_error::create( 0, "" );
        }
    }

    const unsigned int providedRows = jsonArrayOfArrays.size( );
    const unsigned int providedCols = jsonArrayOfArrays.front( ).size( );
    if ( ( rows >= 0 && int( providedRows ) != rows ) || ( cols >= 0 && int( providedCols ) != cols ) )
    {
        std::cerr << "Expected matrix of size " << rows << "x" << cols
                  << ", received matrix of size " << providedRows << "x" << providedCols << "." << std::endl;
        throw nlohmann::detail::type_error::create( 0, "" );
    }

    matrix.resize( providedRows, providedCols );
    for ( unsigned int r = 0; r < providedRows; ++r )
    {
        if ( jsonArrayOfArrays.at( r ).size( ) != providedCols )
        {

            std::cerr << "Unconsistent matrix size: some rows have different number of columns." << std::endl;
            throw nlohmann::detail::type_error::create( 0, "" );
        }
        for ( unsigned int c = 0; c < providedCols; ++c )
        {
            matrix( r, c ) = jsonArrayOfArrays.at( r ).at( c );
        }
    }
}
}

[nlohmann]

In order to asses your issue, we need the following information:

• What is the issue you have?

• Please describe the steps to reproduce the issue. Can you provide a small but working code example?

• What is the expected behavior?

• And what is the actual behavior instead?

• Which compiler and operating system are you using? Is it a supported compiler?

• Did you use a released version of the library or the version from the develop branch?

• If you experience a compilation error: can you compile and run the unit tests?