image.hpp

 
#ifndef UFO_VISION_IMAGE_HPP
#define UFO_VISION_IMAGE_HPP
 
// UFO
#include <ufo/vision/color.hpp>
 
// STL
#include <algorithm>
#include <cstddef>
#include <format>
#include <iterator>
#include <memory>
#include <ranges>
#include <span>
#include <stdexcept>
#include <version>
 
namespace ufo
{
template <class T>
class Image
{
 public:
    using value_type = T;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;
    using reference = T&;
    using const_reference = T const&;
    using pointer = T*;
    using const_pointer = T const*;
    using iterator = T*;
    using const_iterator = T const*;
    using reverse_iterator = std::reverse_iterator<iterator>;
    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
    Image() = default;
 
    Image(Image const& other)
        : data_(std::make_unique_for_overwrite<T[]>(other.size()))
        , rows_(other.rows_)
        , cols_(other.cols_)
    {
        std::ranges::copy(other, begin());
    }
 
    Image(Image&&) = default;
 
    Image(size_type rows, size_type cols, T const& value = T{})
        : data_(std::make_unique_for_overwrite<T[]>(rows * cols)), rows_(rows), cols_(cols)
    {
        std::ranges::fill(*this, value);
    }
 
    Image& operator=(Image const& rhs)
    {
        if (this != &rhs) {
            resize(rhs.rows_, rhs.cols_);
            std::ranges::copy(rhs, begin());
        }
        return *this;
    }
 
    Image& operator=(Image&&) = default;
 
    [[nodiscard]] auto& operator[](this auto& self, size_type index)
    {
        return self.data_[index];
    }
 
    [[nodiscard]] auto& operator[](this auto& self, size_type row, size_type col)
    {
        return self.data_[self.index(row, col)];
    }
 
    [[nodiscard]] auto& at(this auto& self, size_type row, size_type col)
    {
        if (self.rows() <= row || self.cols() <= col) {
            throw std::out_of_range(
                std::format("Image::at({}, {}): index out of range [0, {}) x [0, {})", row, col,
                            self.rows(), self.cols()));
        }
        return self.data_[self.index(row, col)];
    }
 
    [[nodiscard]] std::span<T> row(size_type r) noexcept
    {
        return {data_.get() + r * cols_, cols_};
    }
 
    [[nodiscard]] std::span<T const> row(size_type r) const noexcept
    {
        return {data_.get() + r * cols_, cols_};
    }
 
    [[nodiscard]] auto column(this auto& self, size_type c) noexcept
    {
        return std::ranges::iota_view(size_type{}, self.rows_) |
               std::views::transform(
                   [&self, c](size_type r) -> decltype(auto) { return self[r, c]; });
    }
 
    [[nodiscard]] auto begin(this auto& self) noexcept { return self.data_.get(); }
 
    [[nodiscard]] const_iterator cbegin() const noexcept { return begin(); }
 
    [[nodiscard]] auto rbegin(this auto& self) noexcept
    {
        return std::make_reverse_iterator(self.end());
    }
 
    [[nodiscard]] const_reverse_iterator crbegin() const noexcept { return rbegin(); }
 
    [[nodiscard]] auto end(this auto& self) noexcept
    {
        return self.data_.get() + self.size();
    }
 
    [[nodiscard]] const_iterator cend() const noexcept { return end(); }
 
    [[nodiscard]] auto rend(this auto& self) noexcept
    {
        return std::make_reverse_iterator(self.begin());
    }
 
    [[nodiscard]] const_reverse_iterator crend() const noexcept { return rend(); }
 
    [[nodiscard]] auto data(this auto& self) noexcept { return self.data_.get(); }
 
    [[nodiscard]] bool empty() const noexcept { return 0 == size(); }
 
    [[nodiscard]] constexpr size_type rows() const noexcept { return rows_; }
 
    [[nodiscard]] constexpr size_type cols() const noexcept { return cols_; }
 
    [[nodiscard]] constexpr size_type size() const noexcept { return rows_ * cols_; }
 
    [[nodiscard]] constexpr size_type index(size_type row, size_type col) const noexcept
    {
        return row * cols_ + col;
    }
 
    void swap(Image& other) noexcept
    {
        using std::swap;
        swap(data_, other.data_);
        swap(rows_, other.rows_);
        swap(cols_, other.cols_);
    }
 
    void resize(size_type rows, size_type cols)
    {
        if (rows * cols != size()) {
            data_ = std::make_unique_for_overwrite<T[]>(rows * cols);
        }
        rows_ = rows;
        cols_ = cols;
    }
 
    void fill(T const& value) { std::ranges::fill(*this, value); }
 
    void clear() noexcept
    {
        data_.reset();
        rows_ = 0;
        cols_ = 0;
    }
 
    [[nodiscard]] Image transposed() const
    {
        Image ret(cols_, rows_);
        for (size_type r = 0; r < rows(); ++r) {
            for (size_type c = 0; c < cols(); ++c) {
                ret[c, r] = (*this)[r, c];
            }
        }
        return ret;
    }
 
    void flipHorizontal() noexcept
    {
        for (size_type r = 0; r < rows(); ++r) {
            auto r_span = row(r);
            std::ranges::reverse(r_span);
        }
    }
 
    void flipVertical() noexcept
    {
        for (size_type r = 0; r < rows() / 2; ++r) {
            auto r1 = row(r);
            auto r2 = row(rows() - 1 - r);
            std::ranges::swap_ranges(r1, r2);
        }
    }
 
    [[nodiscard]] Image rotate90(bool clockwise = true) const
    {
        Image ret(cols_, rows_);
        if (clockwise) {
            for (size_type r = 0; r < rows(); ++r) {
                for (size_type c = 0; c < cols(); ++c) {
                    ret[c, rows() - 1 - r] = (*this)[r, c];
                }
            }
        } else {
            for (size_type r = 0; r < rows(); ++r) {
                for (size_type c = 0; c < cols(); ++c) {
                    ret[cols() - 1 - c, r] = (*this)[r, c];
                }
            }
        }
        return ret;
    }
 
    [[nodiscard]] T sample(float r, float c) const
    {
        if (empty()) {
            return T{};
        }
 
        r = std::clamp(r, 0.0f, 1.0f) * static_cast<float>(rows() - 1);
        c = std::clamp(c, 0.0f, 1.0f) * static_cast<float>(cols() - 1);
 
        size_type r0 = static_cast<size_type>(std::floor(r));
        size_type c0 = static_cast<size_type>(std::floor(c));
        size_type r1 = std::min(r0 + 1, rows() - 1);
        size_type c1 = std::min(c0 + 1, cols() - 1);
 
        float dr = r - static_cast<float>(r0);
        float dc = c - static_cast<float>(c0);
 
        auto s00 = (*this)[r0, c0];
        auto s01 = (*this)[r0, c1];
        auto s10 = (*this)[r1, c0];
        auto s11 = (*this)[r1, c1];
 
        if constexpr (requires { s00 * 1.0f; }) {
            return static_cast<T>(s00 * ((1.0f - dr) * (1.0f - dc)) + s01 * ((1.0f - dr) * dc) +
                                  s10 * (dr * (1.0f - dc)) + s11 * (dr * dc));
        } else {
            return (dr < 0.5f) ? ((dc < 0.5f) ? s00 : s01) : ((dc < 0.5f) ? s10 : s11);
        }
    }
 
    [[nodiscard]] T samplePixel(float r, float c) const
    {
        if (empty()) {
            return T{};
        }
        float r_norm = (rows() > 1) ? r / static_cast<float>(rows() - 1) : 0.0f;
        float c_norm = (cols() > 1) ? c / static_cast<float>(cols() - 1) : 0.0f;
        return sample(r_norm, c_norm);
    }
 
    void rescale(size_type rows, size_type cols)
    {
        if (rows == rows_ && cols == cols_) {
            return;
        }
        *this = rescaled(rows, cols);
    }
 
    [[nodiscard]] Image rescaled(size_type rows, size_type cols) const
    {
        Image ret(rows, cols);
        for (size_type r = 0; r < rows; ++r) {
            float r_norm = (rows > 1) ? static_cast<float>(r) / (rows - 1) : 0.0f;
            for (size_type c = 0; c < cols; ++c) {
                float c_norm = (cols > 1) ? static_cast<float>(c) / (cols - 1) : 0.0f;
                ret[r, c]    = sample(r_norm, c_norm);
            }
        }
        return ret;
    }
 
    void upscale(float factor)
    {
        rescale(static_cast<size_type>(rows() * factor),
                static_cast<size_type>(cols() * factor));
    }
 
    void downscale(float factor)
    {
        rescale(static_cast<size_type>(rows() / factor),
                static_cast<size_type>(cols() / factor));
    }
 
 private:
    std::unique_ptr<T[]> data_;
    size_type            rows_{};
    size_type            cols_{};
};
 
template <class T>
void swap(Image<T>& lhs, Image<T>& rhs) noexcept
{
    lhs.swap(rhs);
}
 
using ImageSmallGray = Image<SmallGray>;
using ImageFineGray = Image<FineGray>;
using ImageSmallRgb = Image<SmallRgb>;
using ImageSmallRgbA = Image<SmallRgbA>;
using ImageFineRgb = Image<FineRgb>;
using ImageFineRgbA = Image<FineRgbA>;
 
//
// Convert
//
 
template <class From, class To>
void convert(Image<From> const& src, Image<To>& dest)
{
    if constexpr (std::is_same_v<To, From>) {
        dest = src;
    } else {
        dest.resize(src.rows(), src.cols());
        std::ranges::transform(src, dest.begin(),
                               [](auto const& x) { return convert<To>(x); });
    }
}
 
template <class To, class From>
[[nodiscard]] Image<To> convert(Image<From> const& image)
{
    if constexpr (std::is_same_v<To, From>) {
        return image;
    } else {
        Image<To> ret(image.rows(), image.cols());
        std::ranges::transform(image, ret.begin(),
                               [](auto const& x) { return convert<To>(x); });
        return ret;
    }
}
 
}  // namespace ufo
 
#endif  // UFO_VISION_IMAGE_HPP