pointcloud_data.h

Go to the documentation of this file.

 
#pragma once
 
#include <adtfmediadescription/adtf_mediadescription.h>
 
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <unordered_map>
#include <variant>
 
#include "stream_meta_type_pointcloud.h"
#include "pointcloud_access.h"

namespace adtf
{
namespace devicetb
{
namespace sdk
{
namespace pointcloud
{
namespace navigation
{
 
class cPointCloudTypeHelper
{
public:
    class cDynamicSampleHeader
    {
    public:
        cDynamicSampleHeader& EnableSensorTransformation()
        {
            m_bTransformation = true;
            return *this;
        }
 
        cDynamicSampleHeader& EnableSize()
        {
            m_bSize = true;
            return *this;
        }
 
        cDynamicSampleHeader& AddAttribute(std::string_view strName)
        {
            m_oAttributes.emplace_back(strName);
            return *this;
        }
 
        ddl::DDStructure GetDefinition()
        {
            auto oPointCloudDescription = ddl::DDStructure("point_cloud_sample_header");
 
            if (m_bTransformation)
            {
                static const auto oTransformationDescription =
                    ddl::DDStructureGenerator<tSensorTransformation>("sensor_transformation")
                        .addElement("x", &tSensorTransformation::x)
                        .addElement("y", &tSensorTransformation::y)
                        .addElement("z", &tSensorTransformation::z)
                        .addElement("roll", &tSensorTransformation::roll)
                        .addElement("pitch", &tSensorTransformation::pitch)
                        .addElement("yaw", &tSensorTransformation::yaw);
 
                oPointCloudDescription.addElement(stream_meta_type_pointcloud_properties::Transformation,
                                                  oTransformationDescription);
            }
 
            // Deploy dynamic attributes
            if (!m_oAttributes.empty())
            {
                static const auto oDataTypeEnum = ddl::DDEnumGenerator<tAttribute::tDataType>(
                    "data_type", {{"dt_boolean", tAttribute::tDataType::dt_boolean},
                                  {"dt_uint_8", tAttribute::tDataType::dt_uint8},
                                  {"dt_int_8", tAttribute::tDataType::dt_int8},
                                  {"dt_uint_16", tAttribute::tDataType::dt_uint16},
                                  {"dt_int_16", tAttribute::tDataType::dt_int16},
                                  {"dt_float16", tAttribute::tDataType::dt_float16},
                                  {"dt_uint_32", tAttribute::tDataType::dt_uint32},
                                  {"dt_int_32", tAttribute::tDataType::dt_int32},
                                  {"dt_float32", tAttribute::tDataType::dt_float32},
                                  {"dt_uint_64", tAttribute::tDataType::dt_uint64},
                                  {"dt_int_64", tAttribute::tDataType::dt_int64},
                                  {"dt_float64", tAttribute::tDataType::dt_float64},
                                  {"dt_computed_from_index", tAttribute::tDataType::dt_computed_from_index}});
 
                static const auto oEndianEnum = ddl::DDEnumGenerator<tAttribute::tInMemory::eEndianess>(
                    "endianess", {{"endian_big", tAttribute::tInMemory::eEndianess::endian_big},
                                  {"endian_little", tAttribute::tInMemory::eEndianess::endian_little}});
 
                static const auto oInMemoryDescription =
                    ddl::DDStructureGenerator<tAttribute::tInMemory>("in_memory")
                        .addElement("endianess", &tAttribute::tInMemory::endianess, oEndianEnum)
                        .addElement("offset", &tAttribute::tInMemory::offset)
                        .addElement("stride", &tAttribute::tInMemory::stride);
 
                static const auto oComputedFromIndexDescription =
                    ddl::DDStructureGenerator<tAttribute::tComputedFromIndex>("computed_from_index")
                        .addElement("stride_to_increment", &tAttribute::tComputedFromIndex::stride_to_increment)
                        .addElement("stride_to_reset", &tAttribute::tComputedFromIndex::stride_to_reset)
                        .addElement("increment", &tAttribute::tComputedFromIndex::increment)
                        .addElement("offset", &tAttribute::tComputedFromIndex::offset);
 
                static const auto oAttributeDescription =
                    ddl::DDStructureGenerator<tAttribute>("attribute")
                        .addElement("type", &tAttribute::type, oDataTypeEnum)
                        .addElement("in_memory", &tAttribute::sInMemory, oInMemoryDescription)
                        .addElement("computed", &tAttribute::sComputed, oComputedFromIndexDescription);
 
                auto oAttributesDescription = ddl::DDStructure(stream_meta_type_pointcloud_properties::Attributes);
                for (const auto& oUserAttr : m_oAttributes)
                {
                    oAttributesDescription.addElement(oUserAttr, oAttributeDescription);
                }
 
                oPointCloudDescription.addElement(stream_meta_type_pointcloud_properties::Attributes,
                                                  oAttributesDescription);
            }
 
            if (m_bSize)
            {
                oPointCloudDescription.addElement<size_t>(stream_meta_type_pointcloud_properties::Count);
            }
 
            return oPointCloudDescription;
        }
 
    private:
        bool m_bTransformation = false;
        std::vector<std::string> m_oAttributes;
        bool m_bSize = false;
    };

    cPointCloudTypeHelper(const adtf::ucom::iobject_ptr<const adtf::streaming::IStreamType>& pType):
        cPointCloudTypeHelper()
    {
        try
        {
            const auto [strName, strDDL, eRepresentation] =
                adtf::mediadescription::get_media_description_from_stream_type(*pType.Get());
            SetDynamicSampleHeader(ddl::DDStructure(strName, strDDL), eRepresentation);
        }
        catch (...)
        {
        }
 
        adtf::ucom::object_ptr<const adtf::base::IProperties> pProperties;
        THROW_IF_FAILED(pType->GetConfig(pProperties));
 
        // Static: Read transformation from StreamType properties
        if (pProperties->Exists(stream_meta_type_pointcloud_properties::Transformation))
        {
            tSensorTransformation oTransformation;
            oTransformation.x = adtf::base::get_property_by_path<float>(
                *pProperties, stream_meta_type_pointcloud_properties::TransformationX);
            oTransformation.y = adtf::base::get_property_by_path<float>(
                *pProperties, stream_meta_type_pointcloud_properties::TransformationY);
            oTransformation.z = adtf::base::get_property_by_path<float>(
                *pProperties, stream_meta_type_pointcloud_properties::TransformationZ);
            oTransformation.roll = adtf::base::get_property_by_path<float>(
                *pProperties, stream_meta_type_pointcloud_properties::TransformationRoll);
            oTransformation.pitch = adtf::base::get_property_by_path<float>(
                *pProperties, stream_meta_type_pointcloud_properties::TransformationPitch);
            oTransformation.yaw = adtf::base::get_property_by_path<float>(
                *pProperties, stream_meta_type_pointcloud_properties::TransformationYaw);
 
            m_oTransformation = oTransformation;
        }
 
        if (!IsDynamic())
        {
            // Static: Read attributes from StreamType properties
            std::map<std::string, std::pair<std::string, tAttribute>, std::less<>> oFoundAttributes;
            adtf::base::visit_sub_properties(
                *pProperties, stream_meta_type_pointcloud_properties::Attributes,
                [&](const adtf::base::IProperty& oProperty)
                {
                        std::string strOrder;
                        THROW_IF_FAILED(oProperty.GetName(adtf_string_intf(strOrder)));
 
                        adtf::ucom::object_ptr<const adtf::base::IProperties> pSubProperties;
                        THROW_IF_FAILED(oProperty.GetProperties(pSubProperties));
 
                        const auto strAttributeName = adtf::base::get_property_by_path<std::string>(
                            *pSubProperties, stream_meta_type_pointcloud_properties::AttributeName);
 
                        tAttribute oAttribute;
 
                        const auto strDataType = adtf::base::get_property_by_path<std::string>(
                            *pSubProperties, stream_meta_type_pointcloud_properties::AttributeDataType);
 
                        static const std::unordered_map<std::string, tAttribute::tDataType> oDataTypeNames{
                            {"bool", tAttribute::tDataType::dt_boolean},
                            {"uint8", tAttribute::tDataType::dt_uint8},
                            {"int8", tAttribute::tDataType::dt_int8},
                            {"uint16", tAttribute::tDataType::dt_uint16},
                            {"int16", tAttribute::tDataType::dt_int16},
                            {"float16", tAttribute::tDataType::dt_float16},
                            {"uint32", tAttribute::tDataType::dt_uint32},
                            {"int32", tAttribute::tDataType::dt_int32},
                            {"float32", tAttribute::tDataType::dt_float32},
                            {"uint64", tAttribute::tDataType::dt_uint64},
                            {"int64", tAttribute::tDataType::dt_int64},
                            {"float64", tAttribute::tDataType::dt_float64},
                            {"computed", tAttribute::tDataType::dt_computed_from_index}};
 
                        const auto it = oDataTypeNames.find(strDataType);
                        if (it == oDataTypeNames.end())
                        {
                            THROW_ERROR_DESC(ERR_INVALID_TYPE, "Invalid datatype.");
                        }
                        oAttribute.type = it->second;
 
                        if (oAttribute.type == tAttribute::tDataType::dt_computed_from_index)
                        {
                            oAttribute.sComputed.stride_to_increment = adtf::base::get_property_by_path<uint64_t>(
                                *pSubProperties,
                                stream_meta_type_pointcloud_properties::AttributeComputedStrideToIncrement);
                            oAttribute.sComputed.stride_to_reset = adtf::base::get_property_by_path<uint64_t>(
                                *pSubProperties,
                                stream_meta_type_pointcloud_properties::AttributeComputedStrideToReset);
                            oAttribute.sComputed.increment = adtf::base::get_property_by_path<double>(
                                *pSubProperties, stream_meta_type_pointcloud_properties::AttributeComputedIncrement);
                            oAttribute.sComputed.offset = adtf::base::get_property_by_path<double>(
                                *pSubProperties, stream_meta_type_pointcloud_properties::AttributeComputedOffset);
                        }
                        else // In Memory
                        {
                            static const std::unordered_map<std::string, tAttribute::tInMemory::eEndianess>
                                oEndianessNames{{"be", tAttribute::tInMemory::eEndianess::endian_big},
                                                {"le", tAttribute::tInMemory::eEndianess::endian_little}};
 
                            oAttribute.sInMemory.endianess =
                                oEndianessNames.at(adtf::base::get_property_by_path<std::string>(
                                    *pSubProperties,
                                    stream_meta_type_pointcloud_properties::AttributeInMemoryEndianess));
                            oAttribute.sInMemory.offset = adtf::base::get_property_by_path<uint64_t>(
                                *pSubProperties, stream_meta_type_pointcloud_properties::AttributeInMemoryOffset);
                            oAttribute.sInMemory.stride = adtf::base::get_property_by_path<uint64_t>(
                                *pSubProperties, stream_meta_type_pointcloud_properties::AttributeInMemoryStride);
                        }
 
                        oFoundAttributes.emplace(strOrder, std::make_pair(strAttributeName, oAttribute));
                });
 
            for (const auto& oOrderedAttributePair : oFoundAttributes)
            {
                m_oStaticAttributes.add(oOrderedAttributePair.second.first, oOrderedAttributePair.second.second);
            }
        }
        
        // Static: Read count from StreamType properties
        if (pProperties->Exists(stream_meta_type_pointcloud_properties::Count))
        {
            m_oCount = adtf::base::get_property_by_path<size_t>(
                *pProperties, stream_meta_type_pointcloud_properties::Count);
        }
 
        CheckCompatibility();
    }

    cPointCloudTypeHelper(): m_nHeaderSize(0), m_eRepresentation(ddl::DataRepresentation::deserialized)
    {
        // Attributes not present, they need to be constructed
    }

    adtf::ucom::object_ptr<adtf::streaming::IStreamType> GetStreamType() const
    {
        CheckCompatibility();
 
        auto pType = adtf::ucom::make_object_ptr<adtf::streaming::cStreamType>(stream_meta_type_pointcloud());
        adtf::ucom::object_ptr<adtf::base::IProperties> pPropertiesType;
        THROW_IF_FAILED(pType->GetConfig(pPropertiesType));
 
        if (!IsDynamic())
        {
            // Deploy transformation, if present
            if (m_oTransformation)
            {
                THROW_IF_FAILED(CreateAndSetProperty(
                    *pPropertiesType, stream_meta_type_pointcloud_properties::TransformationX, m_oTransformation->x));
                THROW_IF_FAILED(CreateAndSetProperty(
                    *pPropertiesType, stream_meta_type_pointcloud_properties::TransformationY, m_oTransformation->y));
                THROW_IF_FAILED(CreateAndSetProperty(
                    *pPropertiesType, stream_meta_type_pointcloud_properties::TransformationZ, m_oTransformation->z));
                THROW_IF_FAILED(CreateAndSetProperty(*pPropertiesType,
                                                         stream_meta_type_pointcloud_properties::TransformationRoll,
                                                         m_oTransformation->roll));
                THROW_IF_FAILED(CreateAndSetProperty(*pPropertiesType,
                                                         stream_meta_type_pointcloud_properties::TransformationPitch,
                                                         m_oTransformation->pitch));
                THROW_IF_FAILED(CreateAndSetProperty(*pPropertiesType,
                                                         stream_meta_type_pointcloud_properties::TransformationYaw,
                                                         m_oTransformation->yaw));
            }
 
            // Deploy static attributes, if present
            size_t nIndex = 0;
            for (const auto& oStaticAttrTuple : m_oStaticAttributes)
            {
                const auto& strAttributeName = std::get<std::string>(oStaticAttrTuple);
                const auto& oAttribute = std::get<tAttribute>(oStaticAttrTuple);
 
                const auto strPropertyPath = std::string(stream_meta_type_pointcloud_properties::Attributes) + "/" +
                                             std::to_string(nIndex) + "/";
                THROW_IF_FAILED(adtf::base::create_property_tree(*pPropertiesType, strPropertyPath.c_str()));
 
                THROW_IF_FAILED(CreateAndSetProperty(
                    *pPropertiesType, strPropertyPath + stream_meta_type_pointcloud_properties::AttributeName,
                    strAttributeName));
 
                static const std::unordered_map<tAttribute::tDataType, std::string> oDataTypeStrings{
                    {tAttribute::tDataType::dt_boolean, "bool"},    {tAttribute::tDataType::dt_uint8, "uint8"},
                    {tAttribute::tDataType::dt_int8, "int8"},       {tAttribute::tDataType::dt_uint16, "uint16"},
                    {tAttribute::tDataType::dt_int16, "int16"},     {tAttribute::tDataType::dt_float16, "float16"},
                    {tAttribute::tDataType::dt_uint32, "uint32"},   {tAttribute::tDataType::dt_int32, "int32"},
                    {tAttribute::tDataType::dt_float32, "float32"}, {tAttribute::tDataType::dt_uint64, "uint64"},
                    {tAttribute::tDataType::dt_int64, "int64"},     {tAttribute::tDataType::dt_float64, "float64"},
                    {tAttribute::tDataType::dt_computed_from_index, "computed"}};
                THROW_IF_FAILED(CreateAndSetProperty(
                    *pPropertiesType, strPropertyPath + stream_meta_type_pointcloud_properties::AttributeDataType,
                    oDataTypeStrings.at(oAttribute.type)));
 
                if (oAttribute.type == tAttribute::tDataType::dt_computed_from_index)
                {
                    THROW_IF_FAILED(CreateAndSetProperty(
                        *pPropertiesType,
                        strPropertyPath + stream_meta_type_pointcloud_properties::AttributeComputedStrideToIncrement,
                        oAttribute.sComputed.stride_to_increment));
                    THROW_IF_FAILED(CreateAndSetProperty(
                        *pPropertiesType,
                        strPropertyPath + stream_meta_type_pointcloud_properties::AttributeComputedStrideToReset,
                        oAttribute.sComputed.stride_to_reset));
                    THROW_IF_FAILED(CreateAndSetProperty(
                        *pPropertiesType,
                        strPropertyPath + stream_meta_type_pointcloud_properties::AttributeComputedIncrement,
                        oAttribute.sComputed.increment));
                    THROW_IF_FAILED(CreateAndSetProperty(
                        *pPropertiesType,
                        strPropertyPath + stream_meta_type_pointcloud_properties::AttributeComputedOffset,
                        oAttribute.sComputed.offset));
                }
                else
                {
                    static const std::map<tAttribute::tInMemory::eEndianess, std::string> oEndianessStrings = {
                        {tAttribute::tInMemory::eEndianess::endian_big, "be"},
                        {tAttribute::tInMemory::eEndianess::endian_little, "le"}};
 
                    THROW_IF_FAILED(CreateAndSetProperty(
                        *pPropertiesType,
                        strPropertyPath + stream_meta_type_pointcloud_properties::AttributeInMemoryEndianess,
                        oEndianessStrings.at(oAttribute.sInMemory.endianess)));
                    THROW_IF_FAILED(CreateAndSetProperty(
                        *pPropertiesType,
                        strPropertyPath + stream_meta_type_pointcloud_properties::AttributeInMemoryOffset,
                        oAttribute.sInMemory.offset));
                    THROW_IF_FAILED(CreateAndSetProperty(
                        *pPropertiesType,
                        strPropertyPath + stream_meta_type_pointcloud_properties::AttributeInMemoryStride,
                        oAttribute.sInMemory.stride));
                }
                ++nIndex;
            }
 
            // Deploy count, if present
            if (m_oCount)
            {
                THROW_IF_FAILED(CreateAndSetProperty(*pPropertiesType,
                                                         stream_meta_type_pointcloud_properties::Count, *m_oCount));
            }
        }
        else
        {
            assert(m_oDynamicSampleHeader);
            THROW_IF_FAILED(adtf::mediadescription::set_media_description_properties(
                *pPropertiesType, *m_oDynamicSampleHeader, m_eRepresentation));
        }
 
        return pType;
    }

    void SetStaticTransformation(const tSensorTransformation& oTransformation)
    {
        if (m_oTransformationAccess)
        {
            THROW_ERROR_DESC(ERR_ACCESS_DENIED, "Sensor transformation is already defined.");
        }
 
        m_oTransformation = oTransformation;
    }

    void AddStaticAttribute(const std::string& strName, const tAttribute& oAttribute)
    {
        if (IsDynamic())
        {
            THROW_ERROR_DESC(ERR_INVALID_ARG, "Can't add static attribute to dynamic layout.");
        }
        if (m_oStaticAttributes.exists(strName))
        {
            THROW_ERROR_DESC(ERR_INVALID_ARG, "Static attribute '%s' already exists.", strName.c_str());
        }
 
        m_oStaticAttributes.add(strName, oAttribute);
    }

    void SetStaticCount(const size_t nCount)
    {
        if (m_oCountAccess)
        {
            THROW_ERROR_DESC(ERR_INVALID_ARG,
                             "Can't add static count to type with dynamic layout which also contains a count element.");
        }
 
        m_oCount = nCount;
    }
 
    void SetDynamicSampleHeader(ddl::DDStructure oHeader, ddl::DataRepresentation eRepresentation)
    {
        m_oTransformationAccess = std::nullopt;
        m_oDynamicAttributes.clear();
        m_oCountAccess = std::nullopt;
 
        ddl::codec::CodecFactory oCodecFactory(oHeader);
 
        try
        {
            const auto oTransformationElement =
                oCodecFactory.getElement(stream_meta_type_pointcloud_properties::Transformation);
            m_oTransformationAccess.emplace(oTransformationElement, eRepresentation);
        }
        catch (const std::runtime_error&)
        {
        }
 
        const auto oAttributesElement = [&]() -> std::optional<ddl::codec::CodecFactory::Element>
        {
            try
            {
                return oCodecFactory.getElement(stream_meta_type_pointcloud_properties::Attributes);
            }
            catch (const std::runtime_error&)
            {
                return std::nullopt;
            }
        }();
 
        if (oAttributesElement)
        {
            for (const auto& oAttribute : oAttributesElement->getChildElements())
            {
                m_oDynamicAttributes.add(oAttribute.getName(), tAttributeAccess(oAttribute, eRepresentation));
            }
        }
 
        try
        {
            const auto oCountElement = oCodecFactory.getElement(stream_meta_type_pointcloud_properties::Count);
            m_oCountAccess.emplace(oCountElement, eRepresentation);
        }
        catch (const std::runtime_error&)
        {
        }
 
        m_nHeaderSize = oCodecFactory.getStaticBufferSize(eRepresentation);
        m_oDynamicSampleHeader = std::move(oHeader);
        m_eRepresentation = eRepresentation;
    }

    size_t GetHeaderSize() const
    {
        return m_nHeaderSize;
    }

    static size_t GetPayloadSize(size_t nPointCount, const tAttributes& oAttributes) noexcept
    {
        size_t nMax = 0;
        for (const auto& oTuple : oAttributes)
        {
            const auto& oAttribute = std::get<tAttribute>(oTuple);
            nMax = std::max(nMax, oAttribute.sInMemory.offset + nPointCount * oAttribute.sInMemory.stride +
                                      oAttribute.Size());
        }
        return nMax;
    }

    const tAttributes& GetStaticAttributes() const
    {
        return m_oStaticAttributes;
    }

    const std::vector<std::string> GetDynamicAttributes() const
    {
        std::vector<std::string> oResult;
        for (const auto& oAttributeTuple : m_oDynamicAttributes)
        {
            oResult.emplace_back(std::get<std::string>(oAttributeTuple));
        }
 
        return oResult;
    }

    const std::vector<std::string> GetAttributes() const
    {
        std::vector<std::string> oResult = GetDynamicAttributes();
 
        for (const auto& oAttributeTuple : m_oStaticAttributes)
        {
            oResult.emplace_back(std::get<std::string>(oAttributeTuple));
        }
 
        return oResult;
    }

    const std::optional<tSensorTransformation>& GetTransformation() const
    {
        if (m_oTransformationAccess)
        {
            THROW_ERROR_DESC(ERR_NOT_SUPPORTED, "Can't predict sensor transformation for an external source.");
        }
 
        return m_oTransformation;
    }

    const std::optional<size_t> GetCount() const
    {
        if (m_oCountAccess)
        {
            THROW_ERROR_DESC(ERR_NOT_SUPPORTED, "Can't predict amount of points in pointcloud for an external source.");
        }
 
        return m_oCount;
    }

    bool IsDynamic() const
    {
        return m_oDynamicSampleHeader.has_value();
    }
 
public:
    struct tPointCloudAccess
    {
        tPointCloudAccess() = delete;
        tPointCloudAccess(const tPointCloudAccess&) = delete;

        tPointCloudAccess(const cPointCloudTypeHelper& oLayout, const void* pData, size_t nDataSize):
            m_oLayout(oLayout),
            m_oHeader(detail::tConstBuffer(pData, m_oLayout.GetHeaderSize())),
            m_oData(detail::tConstBuffer(static_cast<const std::byte*>(pData) + m_oLayout.GetHeaderSize(),
                                       nDataSize - m_oLayout.GetHeaderSize()))
        {
            Construct(nDataSize);
        }

        tPointCloudAccess(const cPointCloudTypeHelper& oLayout, void* pData, size_t nDataSize):
            m_oLayout(oLayout),
            m_oHeader(detail::tBuffer(pData, m_oLayout.GetHeaderSize())),
            m_oData(detail::tBuffer(static_cast<std::byte*>(pData) + m_oLayout.GetHeaderSize(),
                                  nDataSize - m_oLayout.GetHeaderSize()))
        {
            Construct(nDataSize);
        }

        tPointCloudAccess(const cPointCloudTypeHelper& oLayout, const adtf::streaming::ISampleBuffer& oData):
            m_oLayout(oLayout),
            m_oHeader(detail::tConstBuffer(oData.GetPtr(), m_oLayout.GetHeaderSize())),
            m_oData(detail::tConstBuffer(static_cast<const std::byte*>(oData.GetPtr()) + m_oLayout.GetHeaderSize(),
                                       oData.GetSize() - m_oLayout.GetHeaderSize()))
        {
            Construct(oData.GetSize());
        }

        tPointCloudAccess(const cPointCloudTypeHelper& oLayout, adtf::streaming::ISampleBuffer& oData):
            m_oLayout(oLayout),
            m_oHeader(detail::tBuffer(oData.GetPtr(), m_oLayout.GetHeaderSize())),
            m_oData(detail::tBuffer(static_cast<std::byte*>(oData.GetPtr()) + m_oLayout.GetHeaderSize(),
                                  oData.GetSize() - m_oLayout.GetHeaderSize()))
        {
            Construct(oData.GetSize());
        }
 
        constexpr const cPointCloudTypeHelper& GetLayout() const
        {
            return m_oLayout;
        }
 
        const void* GetData() const
        {
            return std::visit([this](auto&& oData) -> const void* { return oData.pData; }, m_oData);
        }
 
        void* GetMutableData()
        {
            return std::visit(
                [this](auto&& oData) -> void*
                {
                    if constexpr (std::is_same_v<decltype(oData.pData), const void* const>)
                    {
                        THROW_ERROR_DESC(ERR_INVALID_ARG,
                                         "Can't obtain a mutable buffer reference from non-const buffer.");
                    }
                    else
                    {
                        return oData.pData;
                    }
                },
                m_oData);
        }
 
        size_t GetBufferSize() const
        {
            return std::visit([this](auto&& oData) -> size_t { return oData.nSize; }, m_oData);
        }
 
        const tAttributes& GetAttributes() const
        {
            if (m_oResolvedAttributes)
            {
                return *m_oResolvedAttributes;
            }
 
            return m_oLayout.GetStaticAttributes();
        }
 
        const std::optional<tSensorTransformation>& GetTransformation() const
        {
            if (m_oLayout.IsDynamic())
            {
                return m_oResolvedSensorTransformation;
            }
 
            return m_oLayout.GetTransformation();
        }
 
        std::optional<size_t> GetCount() const
        {
            if (m_oResolvedCount)
            {
                return m_oResolvedCount;
            }
 
            return m_oLayout.GetCount();
        }
 
        template <typename Callable, typename Signature = adtf::ucom::nitro::detail::signature_t<Callable>>
        void IteratePoints(Callable&& fnCallback) const
        {
            IteratePointsImplementation(std::function<Signature>(fnCallback), make_tuple_sequence<adtf::ucom::nitro::detail::function_traits<std::remove_reference_t<Callable>>::argument_count, size_t>());
        }
 
        template <typename Callable, typename ...Indices, typename Signature = adtf::ucom::nitro::detail::signature_t<Callable>>
        void IteratePoints(Callable&& fnCallback, Indices... indices) const
        {
            static_assert(adtf::ucom::nitro::detail::function_traits<std::remove_reference_t<Callable>>::argument_count == sizeof...(Indices));
            IteratePointsImplementation(std::function<Signature>(fnCallback), std::forward_as_tuple(indices...));
        }
 
    private:
        template<typename T, T ...I>
        static auto make_tuple_sequence_helper(std::integer_sequence<T, I...>)
        {
            return std::make_tuple(I...);
        }
 
        template<std::size_t I, typename T>
        static auto make_tuple_sequence()
        {
            return make_tuple_sequence_helper(std::make_integer_sequence<T, I>());
        }
 
        template <typename ...Indices, std::size_t... Is>
        auto GetAttributesByIndex(const std::tuple<Indices...>& indices,
                                  std::index_sequence<Is...>) const
        {
            return std::forward_as_tuple(static_cast<const tAttribute&>(GetAttributes().at(std::get<Is>(indices)))...);
        }
 
        template <typename ...Indices>
        auto GetAttributesByIndex(const std::tuple<Indices...>& indices) const
        {
            return GetAttributesByIndex(indices, std::index_sequence_for<Indices...>{});
        }
 
        template <typename ...Attributes, typename ...Indices>
        void IteratePointsImplementation(const std::function<void(Attributes...)>& fnCallback, const std::tuple<Indices...>& indices) const
        {
            const auto oAttributes = GetAttributesByIndex(indices);
            for (size_t nIndex = 0; nIndex < GetCount(); ++nIndex)
            {
                CallWithAttribute<sizeof...(Attributes)>(fnCallback, oAttributes, nIndex);
            }
        }
 
        template <size_t nAttributeIndex, typename ...CallbackAttributes, typename AttributeReferences, typename ...Attributes>
        void CallWithAttribute(const std::function<void(CallbackAttributes...)>& fnCallback,
                               [[maybe_unused]] const AttributeReferences& oAttributes,
                               [[maybe_unused]] size_t nIndex,
                               Attributes&&... args) const
        {
            if constexpr (nAttributeIndex == 0)
            {
                fnCallback(detail::to_type<CallbackAttributes>(std::forward<Attributes>(args))...);
            }
            else
            {
                CallWithAttribute<nAttributeIndex - 1>(fnCallback,
                    oAttributes,
                    nIndex,
                    get_attribute_value(std::get<nAttributeIndex - 1>(oAttributes), detail::tConstBuffer(GetData(), GetBufferSize()), nIndex), std::forward<Attributes>(args)...);
            }
        }
 
        void Construct(const size_t nDataSize)
        {
            if (!m_oLayout.IsDynamic())
            {
                if (m_oLayout.GetHeaderSize() != 0)
                {
                    THROW_ERROR_DESC(ERR_INVALID_ARG, "Static layout must not define a header.");
                }
 
                if (!m_oLayout.GetCount())
                {
                    // Try to calculate count
                    // Get size of of 1 point from attributes
                    size_t nPointSizeBytes = 0;
                    for (const auto& oAttributeTuple : m_oLayout.m_oStaticAttributes)
                    {
                        const auto& oAttribute = std::get<tAttribute>(oAttributeTuple);
                        nPointSizeBytes += oAttribute.Size(oAttribute.type);
                    }
                    // Calculate amount of points
                    if (nPointSizeBytes != 0)
                    {
                        m_oResolvedCount = nDataSize / nPointSizeBytes;
                    }
                }
            }
            else // Dynamic layout
            {
                if (m_oLayout.GetHeaderSize() == 0)
                {
                    THROW_ERROR_DESC(ERR_INVALID_ARG, "Can't target dynamic layout without a header.");
                }
                if (nDataSize < m_oLayout.GetHeaderSize())
                {
                    THROW_ERROR_DESC(ERR_INVALID_ARG, "Passed buffer can't even hold valid header.");
                }
 
                ResolveHeader();
            }
        }
 
        template<typename T, typename Access>
        T Resolve(const Access& oHeaderAccess) const
        {
            return std::visit(
                [&oHeaderAccess](auto&& oHeader) -> T
                {
                    if constexpr (!std::is_same_v<std::monostate, std::decay_t<decltype(oHeader)>>)
                    {
                        return oHeaderAccess.getMember(oHeader.pData, oHeader.nSize);
                    }
                    else
                    {
                        return T{};
                    }
                },
                m_oHeader);
        }
 
        tAttributes ResolveAttributes() const
        {
            tAttributes oResult;
            for (const auto& oAttribute : m_oLayout.m_oDynamicAttributes)
            {
                oResult.add(std::get<0>(oAttribute), Resolve<tAttribute>(std::get<1>(oAttribute)));
            }
            return oResult;
        }
 
        void ResolveHeader()
        {
            if (m_oLayout.m_oTransformationAccess)
            {
                m_oResolvedSensorTransformation = Resolve<tSensorTransformation>(*m_oLayout.m_oTransformationAccess);
            }
            m_oResolvedAttributes = ResolveAttributes();
 
            if (m_oLayout.m_oCountAccess)
            {
                m_oResolvedCount = Resolve<size_t>(*m_oLayout.m_oCountAccess);
            }
 
            // If not present, derive count from attributes and buffer size
            if (!m_oResolvedCount && m_oResolvedAttributes)
            {
                // Get size of of 1 point from attributes
                size_t nPointSizeBytes = 0;
                for (const auto& oAttributeTuple : *m_oResolvedAttributes)
                {
                    const auto& oAttribute = std::get<tAttribute>(oAttributeTuple);
                    nPointSizeBytes += oAttribute.Size(oAttribute.type);
                }
                // Calculate amount of points
                if (nPointSizeBytes != 0)
                {
                    m_oResolvedCount = GetBufferSize() / nPointSizeBytes;
                }
            }
        }
 
    private:
        const cPointCloudTypeHelper& m_oLayout;
 
        const std::variant<std::monostate, detail::tBuffer, detail::tConstBuffer> m_oHeader;
        std::optional<tAttributes> m_oResolvedAttributes;
 
        std::optional<tSensorTransformation> m_oResolvedSensorTransformation;
        std::optional<size_t> m_oResolvedCount;
 
        const std::variant<detail::tBuffer, detail::tConstBuffer> m_oData;
    };
 
private:
    struct tSensorTransformationAccess
    {
        tSensorTransformationAccess() = delete;
        tSensorTransformationAccess(const ddl::codec::CodecFactory::Element& oElement,
                                    ddl::DataRepresentation eRepresentation)
        {
            m_oX = adtf::mediadescription::tLeafCodecIndex(oElement.getChildElement("x").getIndex(), eRepresentation)
                       .getLayout();
            m_oY = adtf::mediadescription::tLeafCodecIndex(oElement.getChildElement("y").getIndex(), eRepresentation)
                       .getLayout();
            m_oZ = adtf::mediadescription::tLeafCodecIndex(oElement.getChildElement("z").getIndex(), eRepresentation)
                       .getLayout();
            m_oRoll =
                adtf::mediadescription::tLeafCodecIndex(oElement.getChildElement("roll").getIndex(), eRepresentation)
                    .getLayout();
            m_oPitch =
                adtf::mediadescription::tLeafCodecIndex(oElement.getChildElement("pitch").getIndex(), eRepresentation)
                    .getLayout();
            m_oYaw =
                adtf::mediadescription::tLeafCodecIndex(oElement.getChildElement("yaw").getIndex(), eRepresentation)
                    .getLayout();
        }
 
        tSensorTransformation getMember(const void* pHeader, const size_t nHeaderSize) const
        {
            tSensorTransformation oResult{ddl::codec::LeafValueGetter<float>::getValue(pHeader, nHeaderSize, m_oX),
                                          ddl::codec::LeafValueGetter<float>::getValue(pHeader, nHeaderSize, m_oY),
                                          ddl::codec::LeafValueGetter<float>::getValue(pHeader, nHeaderSize, m_oZ),
                                          ddl::codec::LeafValueGetter<float>::getValue(pHeader, nHeaderSize, m_oRoll),
                                          ddl::codec::LeafValueGetter<float>::getValue(pHeader, nHeaderSize, m_oPitch),
                                          ddl::codec::LeafValueGetter<float>::getValue(pHeader, nHeaderSize, m_oYaw)};
 
            return oResult;
        }
 
    private:
        ddl::codec::LeafLayout m_oX;
        ddl::codec::LeafLayout m_oY;
        ddl::codec::LeafLayout m_oZ;
        ddl::codec::LeafLayout m_oRoll;
        ddl::codec::LeafLayout m_oPitch;
        ddl::codec::LeafLayout m_oYaw;
    };
 
    struct tAttributeAccess
    {
        tAttributeAccess() = delete;
 
        tAttributeAccess(const ddl::codec::CodecFactory::Element& oElement, ddl::DataRepresentation eRepresentation)
        {
            m_oType =
                adtf::mediadescription::tLeafCodecIndex(oElement.getChildElement("type").getIndex(), eRepresentation)
                    .getLayout();
            m_oEndianess = adtf::mediadescription::tLeafCodecIndex(
                               oElement.getChildElement("in_memory.endianess").getIndex(), eRepresentation)
                               .getLayout();
            m_oOffsetMemory = adtf::mediadescription::tLeafCodecIndex(
                                  oElement.getChildElement("in_memory.offset").getIndex(), eRepresentation)
                                  .getLayout();
            m_oStride = adtf::mediadescription::tLeafCodecIndex(oElement.getChildElement("in_memory.stride").getIndex(),
                                                                eRepresentation)
                            .getLayout();
            m_oStrideToInc = adtf::mediadescription::tLeafCodecIndex(
                                 oElement.getChildElement("computed.stride_to_increment").getIndex(), eRepresentation)
                                 .getLayout();
            m_oStrideToReset = adtf::mediadescription::tLeafCodecIndex(
                                   oElement.getChildElement("computed.stride_to_reset").getIndex(), eRepresentation)
                                   .getLayout();
            m_oIncrement = adtf::mediadescription::tLeafCodecIndex(
                               oElement.getChildElement("computed.increment").getIndex(), eRepresentation)
                               .getLayout();
            m_oOffsetComputed = adtf::mediadescription::tLeafCodecIndex(
                                    oElement.getChildElement("computed.offset").getIndex(), eRepresentation)
                                    .getLayout();
        }
 
        tAttribute getMember(const void* pHeader, const size_t nHeaderSize) const
        {
            tAttribute oResult;
            oResult.type = ddl::codec::LeafValueGetter<tAttribute::tDataType>::getValue(pHeader, nHeaderSize, m_oType);
            if (oResult.type != tAttribute::tDataType::dt_computed_from_index)
            {
                oResult.sInMemory.endianess = ddl::codec::LeafValueGetter<tAttribute::tInMemory::eEndianess>::getValue(
                    pHeader, nHeaderSize, m_oEndianess);
                oResult.sInMemory.offset =
                    ddl::codec::LeafValueGetter<size_t>::getValue(pHeader, nHeaderSize, m_oOffsetMemory);
                oResult.sInMemory.stride =
                    ddl::codec::LeafValueGetter<size_t>::getValue(pHeader, nHeaderSize, m_oStride);
            }
            else
            {
                oResult.sComputed.stride_to_increment =
                    ddl::codec::LeafValueGetter<size_t>::getValue(pHeader, nHeaderSize, m_oStrideToInc);
                oResult.sComputed.stride_to_reset =
                    ddl::codec::LeafValueGetter<size_t>::getValue(pHeader, nHeaderSize, m_oStrideToReset);
                oResult.sComputed.increment =
                    ddl::codec::LeafValueGetter<double>::getValue(pHeader, nHeaderSize, m_oIncrement);
                oResult.sComputed.offset =
                    ddl::codec::LeafValueGetter<double>::getValue(pHeader, nHeaderSize, m_oOffsetComputed);
            }
 
            return oResult;
        }
 
    private:
        ddl::codec::LeafLayout m_oType;
        // in_memory
        ddl::codec::LeafLayout m_oEndianess;
        ddl::codec::LeafLayout m_oOffsetMemory;
        ddl::codec::LeafLayout m_oStride;
        // computed
        ddl::codec::LeafLayout m_oStrideToInc;
        ddl::codec::LeafLayout m_oStrideToReset;
        ddl::codec::LeafLayout m_oIncrement;
        ddl::codec::LeafLayout m_oOffsetComputed;
    };
 
    struct tCountAccess
    {
        tCountAccess() = delete;
 
        tCountAccess(const ddl::codec::CodecFactory::Element& oElement, ddl::DataRepresentation eRepresentation)
        {
            m_oCount = adtf::mediadescription::tLeafCodecIndex(oElement.getIndex(), eRepresentation).getLayout();
        }
 
        size_t getMember(const void* pHeader, const size_t nHeaderSize) const
        {
            return ddl::codec::LeafValueGetter<size_t>::getValue(pHeader, nHeaderSize, m_oCount);
        }
 
    private:
        ddl::codec::LeafLayout m_oCount;
    };
 
    void CheckCompatibility() const
    {
        using namespace std::literals;
        // Check mutually exclusiveness
        if (!m_oStaticAttributes.empty() && !m_oDynamicAttributes.empty())
        {
            THROW_ERROR_DESC(ERR_NOT_SUPPORTED, "The defines both static and dynamic attributes, which is not allowed.");
        }
 
        static const std::array<std::string, 6> oReservedAttributes{"x"s, "y"s, "z"s, "distance"s, "yaw"s, "pitch"s};
        size_t nMandatoryCount = 0;
        for (const auto& strAttribute : oReservedAttributes)
        {
            if (m_oStaticAttributes.exists(strAttribute))
            {
                nMandatoryCount++;
            }
            else if (m_oDynamicAttributes.exists(strAttribute))
            {
                nMandatoryCount++;
            }
        }
 
        if (nMandatoryCount < 3)
        {
            THROW_ERROR_DESC(ERR_INVALID_TYPE, "The StreamType is missing mandatory attributes.");
        }
    }
 
    template<typename T>
    static tResult
        CreateAndSetProperty(adtf::base::IProperties& oProperties, const std::string& strPath, const T& oValue)
    {
        RETURN_IF_FAILED(adtf::base::create_property_tree(oProperties, strPath.c_str()));
        RETURN_IF_FAILED(adtf::base::set_property_by_path(oProperties, strPath.c_str(), oValue));
        RETURN_NOERROR;
    }
 
private:
    std::optional<tCountAccess> m_oCountAccess;
    std::optional<tSensorTransformationAccess> m_oTransformationAccess;
    indexed_vector<tAttributeAccess> m_oDynamicAttributes;
 
    tAttributes m_oStaticAttributes;
    std::optional<tSensorTransformation> m_oTransformation;
    std::optional<size_t> m_oCount;
    size_t m_nHeaderSize = 0;
    std::optional<ddl::DDStructure> m_oDynamicSampleHeader;
    ddl::DataRepresentation m_eRepresentation;
};
 
} // namespace navigation
 
using cPointCloudTypeHelper = navigation::cPointCloudTypeHelper;
 
} // namespace pointcloud
} // namespace sdk
} // namespace devicetb
} // namespace adtf