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
{
 
inline ImageView::ImageView(const peak::core::ImageView::ExtractedPayload& payload)
    : m_metadata{ std::make_shared<peak::common::Metadata>() }
    , m_payload{ payload }
{}
 
inline ImageView::ImageView(const std::shared_ptr<peak::core::Buffer>& buffer)
    : ImageView(ExtractPayload(buffer))
{
    m_metadata->SetValueByKey<peak::common::MetadataKey::DeviceFrameID>(buffer->FrameID());
 
    // NOTE: We need to try the timestamp, as it may not be supported by the TL
    try
    {
        m_metadata->SetValueByKey<peak::common::MetadataKey::DeviceTimestamp>(buffer->Timestamp_ns());
    }
    catch (const peak::core::NotAvailableException&)
    {}
    catch (const peak::core::NotImplementedException&)
    {}
}
 
inline ImageView::ImageView(const std::shared_ptr<core::BufferPart>& part)
    : ImageView(ExtractPayloadFromBufferPart(part))
{
    const auto buffer = part->ParentBuffer();
    m_metadata->SetValueByKey<peak::common::MetadataKey::DeviceFrameID>(buffer->FrameID());
 
    // NOTE: We need to try the timestamp, as it may not be supported by the TL
    try
    {
        m_metadata->SetValueByKey<peak::common::MetadataKey::DeviceTimestamp>(buffer->Timestamp_ns());
    }
    catch (const peak::core::NotAvailableException&)
    {}
    catch (const peak::core::NotImplementedException&)
    {}
}
 
inline ImageView::ExtractedPayload ImageView::ExtractPayload(
    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);
    }
    else if (buffer->PayloadType() == core::BufferPayloadType::Chunk)
    {
        return ExtractPayloadTypeChunk(buffer);
    }
    else
    {
        throw core::InvalidCastException("Buffer has no image data and no chunks.");
    }
}
 
inline ImageView::ExtractedPayload ImageView::ExtractPayloadTypeImage(
    const std::shared_ptr<peak::core::Buffer>& buffer)
{
    assert(buffer->PixelFormatNamespace() != core::PixelFormatNamespace::IIDC
        && buffer->PixelFormatNamespace() != core::PixelFormatNamespace::Custom);
 
    size_t usableHeight = buffer->Height();
    const size_t usableWidth = buffer->Width();
    size_t usableBytes = buffer->Size() - buffer->ImageOffset();
    uint8_t* 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 imageSizeWithoutChunks = chunks[0]->Size();
 
        for (const auto& chunk : chunks)
        {
            if (0x73020405 == chunk->ID())
            {
                auto* chunkBase = static_cast<uint16_t*>(chunk->BasePtr());
 
                usableHeight = static_cast<size_t>(chunkBase[1]);
                const auto usableOffsetY = static_cast<size_t>(chunkBase[3]);
 
                // Pitch per line
                const auto pitch = imageSizeWithoutChunks / buffer->Height();
                const auto cutOffTop = pitch * usableOffsetY;
                const auto cutOff = (buffer->Height() - usableHeight) * pitch;
 
                firstPixelPtr += cutOffTop;
                usableBytes = imageSizeWithoutChunks - cutOff;
 
                break;
            }
        }
    }
 
    return { { static_cast<uint32_t>(usableWidth), static_cast<uint32_t>(usableHeight) },
        static_cast<peak::common::PixelFormat>(buffer->PixelFormat()), firstPixelPtr, usableBytes };
}
 
inline ImageView::ExtractedPayload ImageView::ExtractPayloadTypeChunk(
    const std::shared_ptr<peak::core::Buffer>& buffer)
{
    auto remoteNodeMap = buffer->ParentDataStream()->ParentDevice()->RemoteDevice()->NodeMaps()[0];
    remoteNodeMap->UpdateChunkNodes(buffer);
 
    auto chunkWidth = remoteNodeMap->FindNode<core::nodes::IntegerNode>("ChunkWidth");
    if (chunkWidth->AccessStatus() == core::nodes::NodeAccessStatus::NotAvailable)
    {
        throw core::InvalidCastException("Buffer has no ChunkWidth.");
    }
    auto width = chunkWidth->Value();
 
    auto chunkHeight = remoteNodeMap->FindNode<core::nodes::IntegerNode>("ChunkHeight");
    if (chunkHeight->AccessStatus() == core::nodes::NodeAccessStatus::NotAvailable)
    {
        throw core::InvalidCastException("Buffer has no ChunkHeight.");
    }
    auto height = chunkHeight->Value();
 
    peak::common::Size size(static_cast<uint32_t>(width), static_cast<uint32_t>(height));
 
    auto chunkPixelFormat = remoteNodeMap->FindNode<core::nodes::EnumerationNode>("ChunkPixelFormat");
    if (chunkPixelFormat->AccessStatus() == core::nodes::NodeAccessStatus::NotAvailable)
    {
        throw core::InvalidCastException("Buffer has no ChunkPixelFormat.");
    }
    auto pixelFormatValue = chunkPixelFormat->CurrentEntry()->NumericValue();
    auto pixelFormat = static_cast<peak::common::PixelFormat>(pixelFormatValue);
 
    // assume first chunks is image data
    auto imageData = buffer->Chunks()[0];
    auto rawData = static_cast<uint8_t*>(imageData->BasePtr());
    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 ImageView::ExtractedPayload ImageView::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)
    {
        assert(part->FormatNamespace() != static_cast<uint64_t>(core::PixelFormatNamespace::IIDC)
            && part->FormatNamespace() != static_cast<uint64_t>(core::PixelFormatNamespace::Custom));
 
        const size_t height = part->Height();
        const size_t width = part->Width();
        return { { static_cast<uint32_t>(width), static_cast<uint32_t>(height) },
            static_cast<peak::common::PixelFormat>(part->Format()), static_cast<uint8_t*>(part->BasePtr()),
            part->Size() };
    }
    else
    {
        throw core::InvalidCastException("BufferPart has no image data.");
    }
}
 
inline const uint8_t* ImageView::GetData() const
{
    return m_payload.m_rawData;
}
 
inline uint8_t* ImageView::GetData()
{
    return m_payload.m_rawData;
}
 
inline std::size_t ImageView::GetSizeInBytes() const
{
    return m_payload.m_sizeInBytes;
}
 
inline peak::common::PixelFormat ImageView::GetPixelFormat() const
{
    return m_payload.m_pixelFormat;
}
 
inline peak::common::PixelFormatInfo ImageView::GetPixelFormatInfo() const
{
    return peak::common::PixelFormatInfo(m_payload.m_pixelFormat);
}
 
inline peak::common::Size ImageView::GetSize() const
{
    return m_payload.m_size;
}
 
inline uint32_t ImageView::GetWidth() const
{
    return m_payload.m_size.GetWidth();
}
 
inline uint32_t ImageView::GetHeight() const
{
    return m_payload.m_size.GetHeight();
}
 
inline size_t ImageView::GetBitsPerPixel() const
{
    return peak::common::PixelFormatInfo(m_payload.m_pixelFormat).GetAllocatedBitsPerPixel();
}
 
inline size_t ImageView::GetBytesPerLine() const
{
    const auto pixelformatInfo = peak::common::PixelFormatInfo(m_payload.m_pixelFormat);
 
    return (pixelformatInfo.GetSizeInBytes(m_payload.m_size) / m_payload.m_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;
}
 
} // namespace core
} // namespace peak