image_region.h

Go to the documentation of this file.

 
#pragma once
 
#include "pixel_format.h"
#include "types/image_types.h"
 
#include <vector>
#include <cstddef>
#include <concepts>
#include <span>
#include <cassert>
#include <limits>
#include <cstdint>
#include <mdspan>
namespace CaptureMoment::Core {
 
namespace Common {
 
struct ImageRegion {
 
    // ============================================================
    // Dimensions & Meta-data
    // ============================================================
 
    ImageCoord m_x{0};
 
    ImageCoord m_y{0};
 
    ImageDim m_width{0};
 
    ImageDim m_height{0};
 
    ImageChan m_channels{4};
 
    PixelFormat m_format{PixelFormat::RGBA_F32};
 
    std::vector<float> m_data;
 
    // ============================================================
    // Constructors
    // ============================================================
 
    ImageRegion() = default;
 
    ImageRegion(ImageDim w, ImageDim h, ImageChan ch, PixelFormat fmt = PixelFormat::RGBA_F32)
        : m_width(w)
        , m_height(h)
        , m_channels(ch)
        , m_format(fmt)
        , m_data(static_cast<std::size_t>(w) * h * ch) // Safe multiplication
    {}
 
 
    ImageRegion(std::vector<float>&& data, ImageDim w, ImageDim h, ImageChan ch,
                ImageCoord x = 0, ImageCoord y = 0, PixelFormat fmt = PixelFormat::RGBA_F32)
        : m_x(x)
        , m_y(y)
        , m_width(w)
        , m_height(h)
        , m_channels(ch)
        , m_format(fmt)
        , m_data(std::move(data))
    {}
 
    ImageRegion(std::span<const float> data_span, ImageDim w, ImageDim h, ImageChan ch,
                ImageCoord x = 0, ImageCoord y = 0, PixelFormat fmt = PixelFormat::RGBA_F32)
        : m_x(x)
        , m_y(y)
        , m_width(w)
        , m_height(h)
        , m_channels(ch)
        , m_format(fmt)
        , m_data(data_span.begin(), data_span.end())
    {}
 
    // ============================================================
    // Accessors & Utilities
    // ============================================================
 
    /*
     * @brief Accessor for width.
     * @return The width of the image region in pixels.
    */
    [[nodiscard]] constexpr ImageDim width() const noexcept { return m_width; }
 
    /*
     * @brief Accessor for height.
     * @return The height of the image region in pixels.
     */
   [[nodiscard]] constexpr ImageDim height() const noexcept { return m_height; }
 
    /*
     * @brief Accessor for channels.
     * @return The number of color channels per pixel.
     */
   [[nodiscard]] constexpr ImageChan channels() const noexcept { return m_channels; }
 
    /*
     * @brief Accessor for pixel format.
     * @return The pixel format of the image region.
     */
   [[nodiscard]] constexpr PixelFormat format() const noexcept { return m_format; }
 
    /*
     * @brief Accessor for x-coordinate.
     * @return The x-coordinate of the image region in the source image.
     */
   [[nodiscard]] constexpr ImageCoord x() const noexcept { return m_x; }
 
    /*
     * @brief Accessor for y-coordinate.
     * @return The y-coordinate of the image region in the source image.
     */
    [[nodiscard]] constexpr ImageCoord y() const noexcept { return m_y; }
 
    [[nodiscard]] constexpr bool isValid() const noexcept
    {
        // 1. Basic sanity checks
        if (m_width == 0 || m_height == 0 || m_channels == 0) {
            return false;
        }
 
        // Optional: Reject unreasonable channel counts (e.g. > 8 for typical RGB/CMYK)
        // Prevents logic errors where dimensions are small but channels are huge causing overflow.
        if (m_channels > 8) {
            return false;
        }
 
        // 2. Safe Calculation Helper (Prevents Overflow)
        // Using a lambda to keep the logic local and constexpr-friendly.
        auto safe_multiply = [](std::size_t a, std::size_t b, std::size_t& out_result) constexpr -> bool {
            if (a != 0 && b > std::numeric_limits<std::size_t>::max() / a) {
                // b > MAX / a  implies  a * b > MAX  (Integer Overflow)
                return false;
            }
            out_result = a * b;
            return true;
        };
 
        // 3. Calculate pixel count safely (width * height)
        std::size_t pixel_count = 0;
        if (!safe_multiply(m_width, m_height, pixel_count)) {
            return false; // Overflow detected in width * height
        }
 
        // 4. Calculate total elements safely (pixel_count * channels)
        std::size_t expected_size = 0;
        if (!safe_multiply(pixel_count, m_channels, expected_size)) {
            return false; // Overflow detected in total elements
        }
 
        // 5. Consistency Check
        // Ensure the vector holds exactly the amount of data expected.
        return m_data.size() == expected_size;
    }
 
    [[nodiscard]] constexpr ImageSize sizeInBytes() const noexcept {
        return m_data.size() * sizeof(float);
    }
 
    [[nodiscard]] constexpr ImageSize getDataSize() const noexcept {
        return m_data.size();
    }
 
    template <typename Self>
    [[nodiscard]] constexpr auto getBuffer(this Self&& self)  noexcept {
        return std::span{self.m_data};
    }
 
    template <typename Self>
    [[nodiscard]] auto& operator()(this Self&& self, std::size_t y, std::size_t x, std::size_t c) noexcept {
        assert(y < self.m_height);
        assert(x < self.m_width);
        assert(c < self.m_channels);
        const std::size_t idx = (y * self.m_width + x) * self.m_channels + c;
        return self.m_data[idx];
    }
 
    template <typename Self>
    [[nodiscard]] auto getMdSpan(this Self&& self) noexcept {
        using ValueType = std::remove_reference_t<decltype(self.m_data[0])>;
        return std::mdspan<ValueType, std::dextents<std::size_t, 3>>(
            self.m_data.data(), self.m_height, self.m_width, self.m_channels
        );
    }
};
 
// ============================================================
// C++23 Concepts
// ============================================================
 
template<typename T>
concept ImageLike = requires(const T& t)
{
    // Must have dimensions
    { t.m_width } -> std::convertible_to<Common::ImageDim>;
    { t.m_height } -> std::convertible_to<Common::ImageDim>;
    { t.m_channels } -> std::convertible_to<Common::ImageChan>;
 
    // Must have a validity check
    { t.isValid() } -> std::same_as<bool>;
 
    // Must support read-only access via getBuffer() or similar
    // (We check if it provides a view into contiguous float data)
    { t.getBuffer() } -> std::convertible_to<std::span<const float>>;
};
 
template<typename T>
concept MutableImageLike = ImageLike<T> && requires(T& t)
{
    { t.getBuffer() } -> std::convertible_to<std::span<float>>;
};
 
} // namespace Common
 
} // namespace CaptureMoment::Core