pointcloud_types.h

Go to the documentation of this file.

 
#pragma once
 
#include <algorithm>
#include <cinttypes>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>

namespace adtf
{
namespace devicetb
{
namespace sdk
{
namespace pointcloud
{
 
namespace navigation
{
#pragma pack(push, 1)
 
// Memory layout description for each individual axis.
struct tAttribute
{
    enum struct tDataType : size_t
    {
        // 8 bit boolean.
        dt_boolean = 0,
        // Fixed size integers.
        dt_uint8 = 1,
        dt_int8 = 2,
        dt_uint16 = 3,
        dt_int16 = 4,
        dt_uint32 = 5,
        dt_int32 = 6,
        dt_uint64 = 7,
        dt_int64 = 8,
        // IEEE754 floating point types.
        dt_float16 = 9,
        dt_float32 = 10,
        dt_float64 = 11,
        dt_computed_from_index = 12
    };
 
    tDataType type = tDataType::dt_boolean;
 
    static constexpr size_t Size(const tDataType& eType) noexcept
    {
        switch (eType)
        {
            case tDataType::dt_boolean:
            case tDataType::dt_uint8:
            case tDataType::dt_int8:
            {
                return 1;
            }
            case tDataType::dt_uint16:
            case tDataType::dt_int16:
            case tDataType::dt_float16:
            {
                return 2;
            }
            case tDataType::dt_uint32:
            case tDataType::dt_int32:
            case tDataType::dt_float32:
            {
                return 4;
            }
            case tDataType::dt_uint64:
            case tDataType::dt_int64:
            case tDataType::dt_float64:
            {
                return 8;
            }
            case tDataType::dt_computed_from_index:
            {
                return 0;
            }
        }
        return 0;
    }
 
    struct tInMemory
    {
        enum struct eEndianess : size_t
        {
            endian_big = 0,
            endian_little
        };
 
        eEndianess endianess = eEndianess::endian_little;
 
        // In BYTES, relative to payload past pointcloud header.
        size_t offset = 0;
        // Increment in BYTES to next element position.
        size_t stride = 0;
 
        constexpr bool operator==(const tInMemory& oOther) const noexcept
        {
            return oOther.endianess == endianess && oOther.offset == offset && oOther.stride == stride;
        }
 
        constexpr bool operator!=(const tInMemory& oOther) const noexcept
        {
            return !(oOther == *this);
        }
    };
 
    tInMemory sInMemory = {};
 
    struct tComputedFromIndex
    {
        // After how many elements increment is applied
        size_t stride_to_increment = 1;
        // After how many elements reset occurs
        size_t stride_to_reset = 0;
        //
        double increment = 0.0;
        //
        double offset = 0.0;
 
        double Get(size_t index) const
        {
            return ((index % stride_to_reset) / stride_to_increment) * increment + offset;
        }
 
        constexpr bool operator==(const tComputedFromIndex& oOther) const noexcept
        {
            return oOther.stride_to_increment == stride_to_increment && oOther.stride_to_reset == stride_to_reset &&
                   oOther.increment == increment && oOther.offset == offset;
        }
 
        constexpr bool operator!=(const tComputedFromIndex& oOther) const noexcept
        {
            return !(oOther == *this);
        }
    };
 
    tComputedFromIndex sComputed = {};
 
    constexpr size_t Size() const noexcept
    {
        return Size(type);
    }
 
    constexpr bool operator==(const tAttribute& oOther) const noexcept
    {
        if (type == tDataType::dt_computed_from_index)
        {
            return oOther.type == type && oOther.sComputed == sComputed;
        }
        else
        {
            return oOther.type == type && oOther.sInMemory == sInMemory;
        }
    }
 
    constexpr bool operator!=(const tAttribute& oOther) const noexcept
    {
        return !(oOther == *this);
    }
};
 
struct tSensorTransformation
{
    float x = 0.0f;
    float y = 0.0f;
    float z = 0.0f;
    float roll = 0.0f;  // x - rotation
    float pitch = 0.0f; // y - rotation
    float yaw = 0.0f;   // z - rotation
 
    constexpr bool operator==(const tSensorTransformation& oOther) const noexcept
    {
        return oOther.x == x && oOther.y == y && oOther.z == z && oOther.roll == roll && oOther.pitch == pitch &&
               oOther.yaw == yaw;
    }
 
    constexpr bool operator!=(const tSensorTransformation& oOther) const noexcept
    {
        return !(oOther == *this);
    }
};
 
#pragma pack(pop)
 
/*
 * Helper class for stable storage with amortized element access of O(1).
 */
template<class T>
struct indexed_vector
{
public:
    using value_type = std::tuple<std::string, T>;
 
    bool add(const std::string& name, T attribute)
    {
        if (exists(name))
        {
            return false;
        }
 
        attributes.emplace_back(name, std::move(attribute));
        return indices.try_emplace(name, attributes.size() - 1).second;
    }
 
    const T& at(const std::string& key) const
    {
        return std::get<T>(attributes.at(indices.at(key)));
    }
 
    const T& at(size_t index) const
    {
        return std::get<T>(attributes.at(index));
    }
 
    size_t size() const
    {
        return attributes.size();
    }
 
    bool exists(const std::string& key) const
    {
        return indices.find(key) != indices.end();
    }
 
    bool empty() const
    {
        return attributes.empty();
    }
 
    void clear()
    {
        attributes.clear();
        indices.clear();
    }
 
    typename std::vector<value_type>::iterator begin()
    {
        return attributes.begin();
    }
 
    typename std::vector<value_type>::iterator end()
    {
        return attributes.end();
    }
 
    typename std::vector<value_type>::const_iterator begin() const
    {
        return attributes.cbegin();
    }
 
    typename std::vector<value_type>::const_iterator end() const
    {
        return attributes.cend();
    }
 
    bool operator==(const indexed_vector& oOther) const noexcept
    {
        return oOther.attributes == attributes;
    }
 
    bool operator!=(const indexed_vector& oOther) const noexcept
    {
        return !(*this == oOther);
    }
 
private:
    std::vector<value_type> attributes;
    std::unordered_map<std::string, size_t> indices;
};
 
using tAttributes = indexed_vector<tAttribute>;
 
namespace detail
{
struct tBuffer
{
    constexpr tBuffer(void* pData, size_t nSize) noexcept: pData(pData), nSize(nSize)
    {
    }
    void* const pData;
    const size_t nSize;
};
 
struct tConstBuffer
{
    constexpr tConstBuffer(const void* pData, size_t nSize) noexcept: pData(pData), nSize(nSize)
    {
    }
    const void* const pData;
    const size_t nSize;
};
} // namespace detail
 
 
} // namespace navigation
 
using tAttribute = navigation::tAttribute;
using tSensorTransformation = navigation::tSensorTransformation;
using tAttributes = navigation::tAttributes;
 
} // namespace pointcloud
} // namespace sdk
} // namespace devicetb
} // namespace adtf