peak_ipl_pixel_line.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_ipl/backend/peak_ipl_backend.h>
#include <peak_ipl/exception/peak_ipl_exception.hpp>
#include <peak_ipl/types/peak_ipl_image.hpp>
#include <peak_ipl/types/peak_ipl_simple_types.hpp>
 
#include <cstddef>
#include <cstdint>
#include <utility>
#include <vector>
 
namespace peak
{
namespace ipl
{
 
class PixelLine
{
public:
    struct Channel
    {
        std::vector<uint32_t> Values;
    };
 
public:
    PixelLine() = delete;
    
    explicit PixelLine(const Image& image, peak::ipl::Orientation orientation, size_t offset);
    
    virtual ~PixelLine();
    
    PixelLine(const PixelLine& other);
 
    PixelLine& operator=(const PixelLine& other);
 
    PixelLine(PixelLine&& other) noexcept;
 
    PixelLine& operator=(PixelLine&& other) noexcept;
 
    PEAK_IPL_NO_DISCARD peak::ipl::PixelFormatName PixelFormatName() const;
 
    PEAK_IPL_NO_DISCARD peak::ipl::Orientation Orientation() const;
 
    PEAK_IPL_NO_DISCARD size_t Offset() const;
 
    PEAK_IPL_NO_DISCARD std::vector<Channel> Channels() const;
 
private:
    PEAK_IPL_PIXEL_LINE_HANDLE m_backendHandle{};
};
 
class PixelRow : public PixelLine
{
public:
    PixelRow() = delete;
    explicit PixelRow(const Image& image, size_t row);
    ~PixelRow() override = default;
    PixelRow(const PixelRow& other) = default;
    PixelRow& operator=(const PixelRow& other) = default;
    PixelRow(PixelRow&& other) = default;
    PixelRow& operator=(PixelRow&& other) = default;
};
 
class PixelColumn : public PixelLine
{
public:
    PixelColumn() = delete;
    explicit PixelColumn(const Image& image, size_t column);
    ~PixelColumn() override = default;
    PixelColumn(const PixelColumn& other) = default;
    PixelColumn& operator=(const PixelColumn& other) = default;
    PixelColumn(PixelColumn&& other) = default;
    PixelColumn& operator=(PixelColumn&& other) = default;
};
 
inline PixelRow::PixelRow(const Image& image, size_t row)
    : PixelLine(image, peak::ipl::Orientation::Horizontal, row)
{}
 
inline PixelColumn::PixelColumn(const Image& image, size_t column)
    : PixelLine(image, peak::ipl::Orientation::Vertical, column)
{}
 
 
inline PixelLine::PixelLine(const Image& image, peak::ipl::Orientation orientation, size_t offset)
{
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelLine_Construct(ImageBackendAccessor::BackendHandle(image),
            static_cast<PEAK_IPL_ORIENTATION>(orientation), offset, &m_backendHandle);
    });
}
 
inline PixelLine::~PixelLine()
{
    if (m_backendHandle)
    {
        (void)PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelLine_Destruct(m_backendHandle);
    }
}
 
inline PixelLine::PixelLine(const PixelLine& other)
{
    if (other.m_backendHandle)
    {
        ExecuteAndMapReturnCodes([&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelLine_Acquire(other.m_backendHandle); });
    }
 
    m_backendHandle = other.m_backendHandle;
}
 
inline PixelLine& PixelLine::operator=(const PixelLine& other)
{
    if (this != &other)
    {
        if (m_backendHandle)
        {
            (void)PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelLine_Destruct(m_backendHandle);
        }
 
        if (other.m_backendHandle)
        {
            ExecuteAndMapReturnCodes(
                [&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelLine_Acquire(other.m_backendHandle); });
        }
    }
 
    m_backendHandle = other.m_backendHandle;
 
    return *this;
}
 
inline PixelLine::PixelLine(PixelLine&& other) noexcept
{
    *this = std::move(other);
}
 
inline PixelLine& PixelLine::operator=(PixelLine&& other) noexcept
{
    if (this != &other)
    {
        if (m_backendHandle != nullptr)
        {
            (void)PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelLine_Destruct(m_backendHandle);
        }
 
        m_backendHandle = other.m_backendHandle;
        other.m_backendHandle = nullptr;
    }
 
    return *this;
}
 
inline peak::ipl::PixelFormatName PixelLine::PixelFormatName() const
{
    peak::ipl::PixelFormatName pixelFormatName = peak::ipl::PixelFormatName::Invalid;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelLine_GetPixelFormat(
            m_backendHandle, reinterpret_cast<PEAK_IPL_PIXEL_FORMAT*>(&pixelFormatName));
    });
 
    return pixelFormatName;
}
 
inline peak::ipl::Orientation PixelLine::Orientation() const
{
    peak::ipl::Orientation orientation = peak::ipl::Orientation::Horizontal;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelLine_GetOrientation(
            m_backendHandle, reinterpret_cast<PEAK_IPL_ORIENTATION*>(&orientation));
    });
 
    return orientation;
}
 
inline size_t PixelLine::Offset() const
{
    size_t offset = 0;
 
    ExecuteAndMapReturnCodes(
        [&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelLine_GetOffset(m_backendHandle, &offset); });
 
    return offset;
}
 
inline std::vector<PixelLine::Channel> PixelLine::Channels() const
{
    std::vector<Channel> channels;
 
    size_t numChannels = 0;
    ExecuteAndMapReturnCodes(
        [&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelLine_GetNumChannels(m_backendHandle, &numChannels); });
 
    for (size_t ch = 0; ch < numChannels; ++ch)
    {
        size_t valueListSize = 0;
        ExecuteAndMapReturnCodes([&] {
            return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelLine_GetValuesForChannel(
                m_backendHandle, ch, nullptr, &valueListSize);
        });
        std::vector<uint32_t> valueList(valueListSize);
        ExecuteAndMapReturnCodes([&] {
            return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelLine_GetValuesForChannel(
                m_backendHandle, ch, valueList.data(), &valueListSize);
        });
 
        channels.emplace_back(Channel{ std::move(valueList) });
    }
 
    return channels;
}
 
} /* namespace ipl */
} /* namespace peak */