peak_image_view_impl.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "peak_image_view.hpp"
 
#include <peak_common/types/peak_common_iimageview.hpp>
#include <peak_common/types/peak_common_metadata.hpp>
 
#include <peak/buffer/peak_buffer.hpp>
#include <peak/buffer/peak_buffer_part.hpp>
#include <peak/data_stream/peak_data_stream.hpp>
#include <peak/device/peak_device.hpp>
#include <peak/exception/peak_exception.hpp>
#include <peak/node_map/peak_node_map.hpp>
 
#include <memory>
 
namespace peak
{
namespace core
{
 
namespace detail
{
 
inline ExtractedPayload ExtractPayloadTypeImage(const std::shared_ptr<peak::core::Buffer>& buffer)
{
    assert(buffer->PixelFormatNamespace() != core::PixelFormatNamespace::IIDC
        && buffer->PixelFormatNamespace() != core::PixelFormatNamespace::Custom);
 
    auto usableHeight = static_cast<uint32_t>(buffer->Height());
    const auto usableWidth = static_cast<uint32_t>(buffer->Width());
    const auto pixelFormatInfo = peak::common::PixelFormatInfo(static_cast<peak::common::PixelFormat>(buffer->PixelFormat()));
    const auto imageSizeWithPadding = buffer->Size() - buffer->ImageOffset();
    auto usableBytes = pixelFormatInfo.GetSizeInBytes({usableWidth, usableHeight});
 
    if (usableBytes > imageSizeWithPadding)
    {
        throw InternalErrorException("Buffer is not large enough to fit the expected image size!");
    }
    auto* firstPixelPtr = static_cast<uint8_t*>(buffer->BasePtr()) + buffer->ImageOffset();
 
    if (buffer->HasChunks())
    {
        auto chunks = buffer->Chunks();
 
        if (chunks.empty())
        {
            throw core::InternalErrorException("Buffer has no chunks.");
        }
 
        const auto imageSizeWithPaddingWithoutChunks = chunks[0]->Size();
 
        for (const auto& chunk : chunks)
        {
            if (0x73020405 == chunk->ID())
            {
                const auto* chunkBase = static_cast<uint16_t*>(chunk->BasePtr());
 
                usableHeight = static_cast<uint32_t>(chunkBase[1]);
                const auto usableOffsetX = static_cast<size_t>(chunkBase[2]);
                if (usableOffsetX != 0)
                {
                    throw InvalidCastException(
                        "Buffer has a non-zero 'UsableOffsetX', which is not supported!");
                }
                const auto usableOffsetY = static_cast<size_t>(chunkBase[3]);
 
 
                const auto pitch = imageSizeWithPaddingWithoutChunks / buffer->Height();
                const auto cutOffTop = pitch * usableOffsetY;
 
                firstPixelPtr += cutOffTop;
                // NOTE: The chunk size may contain padding bytes, so we need
                //       to calculate the usable bytes from the width, height,
                //       and pixel format.
                usableBytes = pixelFormatInfo.GetSizeInBytes({ usableWidth, usableHeight });
                if (usableBytes > imageSizeWithPaddingWithoutChunks)
                {
                    throw InternalErrorException("Chunk size is not large enough to fit the expected image size!");
                }
 
                break;
            }
        }
    }
 
    return { { usableWidth, usableHeight }, static_cast<peak::common::PixelFormat>(buffer->PixelFormat()),
        static_cast<void*>(firstPixelPtr), usableBytes };
}
 
inline ExtractedPayload ExtractPayloadTypeChunk(const std::shared_ptr<peak::core::Buffer>& buffer)
{
    const auto remoteNodeMap = buffer->ParentDataStream()->ParentDevice()->RemoteDevice()->NodeMaps().at(0);
    remoteNodeMap->UpdateChunkNodes(buffer);
 
    const auto chunkWidth = remoteNodeMap->FindNode<core::nodes::IntegerNode>("ChunkWidth");
    if (chunkWidth->AccessStatus() == core::nodes::NodeAccessStatus::NotAvailable)
    {
        throw core::InvalidCastException("Buffer has no ChunkWidth.");
    }
 
    const auto chunkHeight = remoteNodeMap->FindNode<core::nodes::IntegerNode>("ChunkHeight");
    if (chunkHeight->AccessStatus() == core::nodes::NodeAccessStatus::NotAvailable)
    {
        throw core::InvalidCastException("Buffer has no ChunkHeight.");
    }
 
    const peak::common::Size size(
        static_cast<uint32_t>(chunkWidth->Value()), static_cast<uint32_t>(chunkHeight->Value()));
 
    const auto chunkPixelFormat = remoteNodeMap->FindNode<core::nodes::EnumerationNode>("ChunkPixelFormat");
    if (chunkPixelFormat->AccessStatus() == core::nodes::NodeAccessStatus::NotAvailable)
    {
        throw core::InvalidCastException("Buffer has no ChunkPixelFormat.");
    }
 
    const auto pixelFormat = static_cast<peak::common::PixelFormat>(
        chunkPixelFormat->CurrentEntry()->NumericValue());
 
    // assume first chunks is image data
    const auto imageData = buffer->Chunks().at(0);
    const auto rawData = imageData->BasePtr();
    const auto sizeInBytes = imageData->Size();
 
    const auto pixelFormatInfo = peak::common::PixelFormatInfo(pixelFormat);
    const auto expectedDataSize = pixelFormatInfo.GetSizeInBytes(size);
    if (sizeInBytes < expectedDataSize)
    {
        std::stringstream msg;
        msg << "The buffer's first chunk's size (" << imageData->Size() << ") is smaller than the expected data size ("
            << expectedDataSize << ").";
        throw core::InvalidCastException(msg.str());
    }
 
    return { size, pixelFormat, rawData, sizeInBytes };
}
 
inline ExtractedPayload ExtractPayloadFromBufferPart(const std::shared_ptr<core::BufferPart>& part)
{
    if (part == nullptr)
    {
        throw core::InvalidArgumentException("The given part is a nullptr!");
    }
 
    const auto partType = part->Type();
 
    if (partType != core::BufferPartType::Image2D && partType != core::BufferPartType::ConfidenceMap
        && partType != core::BufferPartType::Image3D)
    {
        throw core::InvalidCastException("BufferPart has no image data.");
    }
 
    assert(part->FormatNamespace() != static_cast<uint64_t>(core::PixelFormatNamespace::IIDC)
        && part->FormatNamespace() != static_cast<uint64_t>(core::PixelFormatNamespace::Custom));
 
    return { peak::common::Size{ static_cast<uint32_t>(part->Width()), static_cast<uint32_t>(part->Height()) },
        static_cast<peak::common::PixelFormat>(part->Format()), part->BasePtr(), part->Size() };
}
 
inline ExtractedPayload ExtractPayloadFromBuffer(const std::shared_ptr<peak::core::Buffer>& buffer)
{
    if (buffer == nullptr)
    {
        throw core::InvalidArgumentException("The given buffer is a nullptr!");
    }
 
    if (buffer->HasImage())
    {
        return ExtractPayloadTypeImage(buffer);
    }
 
    if (buffer->PayloadType() == core::BufferPayloadType::Chunk)
    {
        return ExtractPayloadTypeChunk(buffer);
    }
 
    throw core::InvalidCastException("Buffer has no image data and no chunks.");
}
 
inline std::shared_ptr<peak::common::Metadata> ExtractMetadataFromBuffer(const std::shared_ptr<core::Buffer>& buffer)
{
    if (buffer == nullptr)
    {
        throw core::InvalidArgumentException("The given buffer is a nullptr!");
    }
 
    auto metadata = std::make_shared<peak::common::Metadata>();
 
    // NOTE: We need to try, as the timestamp might not be supported by the TL.
    try
    {
        metadata->SetValueByKey<peak::common::MetadataKey::DeviceFrameID>(buffer->FrameID());
        metadata->SetValueByKey<peak::common::MetadataKey::DeviceTimestamp>(buffer->Timestamp_ns());
    }
    catch (const peak::core::NotAvailableException&)
    {}
    catch (const peak::core::NotImplementedException&)
    {}
 
    return metadata;
}
 
} // namespace detail
 
inline ImageView::ImageView(const detail::ExtractedPayload& payload, std::shared_ptr<peak::common::Metadata> metadata)
    : m_metadata{ std::move(metadata) }
    , m_payload{ payload }
{}
 
inline ImageView::ImageView(const std::shared_ptr<peak::core::Buffer>& buffer)
    : ImageView(detail::ExtractPayloadFromBuffer(buffer), detail::ExtractMetadataFromBuffer(buffer))
{
    m_parentBuffer = buffer;
}
 
inline ImageView::ImageView(const std::shared_ptr<core::BufferPart>& part)
    : ImageView(detail::ExtractPayloadFromBufferPart(part), detail::ExtractMetadataFromBuffer(part->ParentBuffer()))
{
    m_parentBuffer = part->ParentBuffer();
}
 
inline const uint8_t* ImageView::GetData() const
{
    return static_cast<uint8_t*>(m_payload.dataPtr);
}
 
inline uint8_t* ImageView::GetData()
{
    return static_cast<uint8_t*>(m_payload.dataPtr);
}
 
inline std::size_t ImageView::GetSizeInBytes() const
{
    return m_payload.dataSize;
}
 
inline peak::common::PixelFormat ImageView::GetPixelFormat() const
{
    return m_payload.pixelFormat;
}
 
inline peak::common::PixelFormatInfo ImageView::GetPixelFormatInfo() const
{
    return peak::common::PixelFormatInfo(m_payload.pixelFormat);
}
 
inline peak::common::Size ImageView::GetSize() const
{
    return m_payload.size;
}
 
inline uint32_t ImageView::GetWidth() const
{
    return m_payload.size.GetWidth();
}
 
inline uint32_t ImageView::GetHeight() const
{
    return m_payload.size.GetHeight();
}
 
inline size_t ImageView::GetBitsPerPixel() const
{
    return peak::common::PixelFormatInfo(m_payload.pixelFormat).GetAllocatedBitsPerPixel();
}
 
inline size_t ImageView::GetBytesPerLine() const
{
    const auto pixelformatInfo = peak::common::PixelFormatInfo(m_payload.pixelFormat);
 
    return pixelformatInfo.GetSizeInBytes(m_payload.size) / m_payload.size.GetHeight();
}
 
inline std::shared_ptr<peak::common::Metadata> ImageView::GetMetadata()
{
    return m_metadata;
}
 
inline std::shared_ptr<const peak::common::Metadata> ImageView::GetMetadata() const
{
    return m_metadata;
}
 
inline std::shared_ptr<peak::core::Buffer> ImageView::GetParentBuffer() const
{
    return LockOrThrow(m_parentBuffer);
}
 
} // namespace core
} // namespace peak