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 */