Messages.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        Open3D: www.open3d.org                            -
// ----------------------------------------------------------------------------
// The MIT License (MIT)
//
// Copyright (c) 2020 www.open3d.org
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
// ----------------------------------------------------------------------------

#pragma once
#include <boost/predef/other/endian.h>

#include <map>
#include <msgpack.hpp>
#include <string>
#include <vector>

#if BOOST_ENDIAN_LITTLE_BYTE
#define ENDIANNESS_STR "<"
#elif BOOST_ENDIAN_BIG_BYTE
#define ENDIANNESS_STR ">"
#else
#error Cannot determine endianness
#endif

namespace open3d {
namespace io {
namespace rpc {
namespace messages {

template <class T>
inline std::string TypeStr() {
    return "";
}
template <>
inline std::string TypeStr<float>() {
    return ENDIANNESS_STR "f4";
}
template <>
inline std::string TypeStr<double>() {
    return ENDIANNESS_STR "f8";
}
template <>
inline std::string TypeStr<int8_t>() {
    return "|i1";
}
template <>
inline std::string TypeStr<int16_t>() {
    return ENDIANNESS_STR "i2";
}
template <>
inline std::string TypeStr<int32_t>() {
    return ENDIANNESS_STR "i4";
}
template <>
inline std::string TypeStr<int64_t>() {
    return ENDIANNESS_STR "i8";
}
template <>
inline std::string TypeStr<uint8_t>() {
    return "|u1";
}
template <>
inline std::string TypeStr<uint16_t>() {
    return ENDIANNESS_STR "u2";
}
template <>
inline std::string TypeStr<uint32_t>() {
    return ENDIANNESS_STR "u4";
}
template <>
inline std::string TypeStr<uint64_t>() {
    return ENDIANNESS_STR "u8";
}

#undef ENDIANNESS_STR

struct Array {
    static std::string MsgId() { return "array"; }

    template <class T>
    static Array FromPtr(const T* const ptr,
                         const std::vector<int64_t>& shape) {
        Array arr;
        arr.type = TypeStr<T>();
        arr.shape = shape;
        arr.data.ptr = (const char*)ptr;
        int64_t num = 1;
        for (int64_t n : shape) num *= n;
        arr.data.size = sizeof(T) * num;
        return arr;
    }
    std::string type;
    std::vector<int64_t> shape;
    msgpack::type::raw_ref data;

    template <class T>
    const T* Ptr() {
        return (T*)data.ptr;
    }

    // macro for creating the serialization/deserialization code
    MSGPACK_DEFINE_MAP(type, shape, data);
};

struct MeshData {
    static std::string MsgId() { return "mesh_data"; }

    Array vertices;
    std::map<std::string, Array> vertex_attributes;

    Array faces;
    std::map<std::string, Array> face_attributes;

    Array lines;
    std::map<std::string, Array> line_attributes;

    std::map<std::string, Array> textures;

    MSGPACK_DEFINE_MAP(vertices,
                       vertex_attributes,
                       faces,
                       face_attributes,
                       lines,
                       line_attributes,
                       textures);
};

struct SetMeshData {
    static std::string MsgId() { return "set_mesh_data"; }

    SetMeshData() : time(0) {}

    std::string path;
    int32_t time;
    std::string layer;

    MeshData data;

    MSGPACK_DEFINE_MAP(path, time, layer, data);
};

struct GetMeshData {
    static std::string MsgId() { return "get_mesh_data"; }

    GetMeshData() : time(0) {}

    std::string path;
    int32_t time;
    std::string layer;

    MSGPACK_DEFINE_MAP(path, time, layer);
};

struct CameraData {
    static std::string MsgId() { return "camera_data"; }

    CameraData() : width(0), height(0) {}

    // extrinsic parameters defining the world to camera transform, i.e.,
    // X_cam = X_world * R + t

    std::array<double, 4> R;
    std::array<double, 3> t;

    std::string intrinsic_model;
    std::vector<double> intrinsic_parameters;

    int width;
    int height;

    std::map<std::string, Array> images;

    MSGPACK_DEFINE_MAP(
            R, t, intrinsic_model, intrinsic_parameters, width, height, images);
};

struct SetCameraData {
    static std::string MsgId() { return "set_camera_data"; }

    SetCameraData() : time(0) {}

    std::string path;
    int32_t time;
    std::string layer;

    CameraData data;

    MSGPACK_DEFINE_MAP(path, time, layer, data);
};

struct SetTime {
    static std::string MsgId() { return "set_time"; }
    SetTime() : time(0) {}
    int32_t time;

    MSGPACK_DEFINE_MAP(time);
};

struct SetActiveCamera {
    static std::string MsgId() { return "set_active_camera"; }
    std::string path;

    MSGPACK_DEFINE_MAP(path);
};

struct SetProperties {
    static std::string MsgId() { return "set_properties"; }
    std::string path;

    // application specific members go here.

    MSGPACK_DEFINE_MAP(path);
};

struct Request {
    std::string msg_id;
    MSGPACK_DEFINE_MAP(msg_id);
};

struct Reply {
    std::string msg_id;
    MSGPACK_DEFINE_MAP(msg_id);
};

struct Status {
    static std::string MsgId() { return "status"; }

    Status() : code(0) {}
    Status(int code, const std::string& str) : code(code), str(str) {}
    static Status OK() { return Status(); }
    static Status ErrorUnsupportedMsgId() {
        return Status(1, "unsupported msg_id");
    }
    static Status ErrorUnpackingFailed() {
        return Status(2, "error during unpacking");
    }

    int32_t code;
    std::string str;

    MSGPACK_DEFINE_MAP(code, str);
};

}  // namespace messages
}  // namespace rpc
}  // namespace io
}  // namespace open3d