pixel_map.hpp

// Copyright Take Vos 2021.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
#include "required.hpp"
#include "geometry/axis_aligned_rectangle.hpp"
#include "geometry/extent.hpp"
#include <algorithm>
#include <cassert>
#include <span>
#include <string>
#include <vector>
 
namespace hi::inline v1 {
 
template<typename T>
class pixel_row {
public:
    using value_type = T;
 
    pixel_row(T *pixels, std::size_t width) noexcept : _pixels(pixels), _width(width) {}
 
    [[nodiscard]] std::size_t width() const noexcept
    {
        return _width;
    }
 
    [[nodiscard]] T const *data() const noexcept
    {
        return _pixels;
    }
 
    [[nodiscard]] T *data() noexcept
    {
        return _pixels;
    }
 
    [[nodiscard]] T const &operator[](std::size_t columnNr) const noexcept
    {
        return _pixels[columnNr];
    }
 
    [[nodiscard]] T &operator[](std::size_t columnNr) noexcept
    {
        return _pixels[columnNr];
    }
 
    [[nodiscard]] T const &at(std::size_t columnNr) const noexcept
    {
        hi_assert(columnNr >= 0 && columnNr < _width);
        return _pixels[columnNr];
    }
 
    [[nodiscard]] T &at(std::size_t columnNr) noexcept
    {
        hi_assert(columnNr >= 0 && columnNr < _width);
        return _pixels[columnNr];
    }
 
private:
    T *_pixels;
 
    std::size_t _width;
};
 
template<typename T>
class pixel_map {
public:
    using value_type = T;
 
    pixel_map() noexcept : _pixels(nullptr), _width(0), _height(0), _stride(0), _self_allocated(true) {}
 
    pixel_map(T *pixels, std::size_t width, std::size_t height, std::size_t stride) noexcept :
        _pixels(pixels), _width(width), _height(height), _stride(stride), _self_allocated(false)
    {
        hi_assert(_stride >= _width);
        hi_assert(_width >= 0);
        hi_assert(_height >= 0);
 
        if (pixels == nullptr) {
            _self_allocated = true;
            _pixels = new T[_height * _stride];
        }
    }
 
    pixel_map(T *pixels, std::size_t width, std::size_t height) noexcept : pixel_map(pixels, width, height, width) {}
 
    pixel_map(std::size_t width, std::size_t height, std::size_t stride) noexcept : pixel_map(nullptr, width, height, stride) {}
 
    pixel_map(std::size_t width, std::size_t height) noexcept : pixel_map(nullptr, width, height, width) {}
 
    ~pixel_map()
    {
        if (_self_allocated) {
            delete[] _pixels;
        }
    }
 
    pixel_map(pixel_map const &other) noexcept :
        _pixels(other._pixels),
        _width(other._width),
        _height(other._height),
        _stride(other._stride),
        _self_allocated(other._self_allocated)
    {
        if (_self_allocated) {
            _pixels = new T[_height * _stride];
 
            for (std::size_t y = 0; y != _height; ++y) {
                hilet src_row = other[y];
                auto dst_row = (*this)[y];
                for (std::size_t x = 0; x != _width; ++x) {
                    dst_row[x] = src_row[x];
                }
            }
        }
    }
 
    pixel_map(pixel_map &&other) noexcept :
        _pixels(other._pixels),
        _width(other._width),
        _height(other._height),
        _stride(other._stride),
        _self_allocated(other._self_allocated)
    {
        hi_axiom(this != &other);
        other._self_allocated = false;
    }
 
    [[nodiscard]] operator bool() const noexcept
    {
        return _pixels != nullptr;
    }
 
    [[nodiscard]] std::size_t width() const noexcept
    {
        return _width;
    }
 
    [[nodiscard]] std::size_t height() const noexcept
    {
        return _height;
    }
 
    [[nodiscard]] std::size_t stride() const noexcept
    {
        return _stride;
    }
 
    pixel_map &operator=(pixel_map const &other)
    {
        hi_return_on_self_assignment(other);
 
        _pixels = other._pixels;
        _width = other._width;
        _height = other._height;
        _stride = other._stride;
        _self_allocated = other._self_allocated;
 
        if (_self_allocated) {
            _pixels = new T[_height * _stride];
 
            for (std::size_t y = 0; y != _height; ++y) {
                hilet src_row = other[y];
                auto dst_row = (*this)[y];
                for (std::size_t x = 0; x != _width; ++x) {
                    dst_row[x] = src_row[x];
                }
            }
        }
        return *this;
    }
 
    pixel_map &operator=(pixel_map &&other) noexcept
    {
        // Self assignment is allowed.
        if (_self_allocated) {
            delete[] _pixels;
        }
        _pixels = other._pixels;
        _width = other._width;
        _height = other._height;
        _stride = other._stride;
        _self_allocated = other._self_allocated;
        other._self_allocated = false;
        return *this;
    }
 
    extent2 extent() const noexcept
    {
        return {narrow_cast<float>(_width), narrow_cast<float>(_height)};
    }
 
    pixel_map submap(std::size_t x, std::size_t y, std::size_t width, std::size_t height) const noexcept
    {
        hi_axiom((x >= 0) && (y >= 0));
        hi_assert((x + width <= _width) && (y + height <= _height));
 
        hilet offset = y * _stride + x;
 
        return pixel_map{_pixels + offset, width, height, _stride};
    }
 
    pixel_map submap(aarectangle rectangle) const noexcept
    {
        hi_axiom(round(rectangle) == rectangle);
        return submap(
            narrow_cast<std::size_t>(rectangle.left()),
            narrow_cast<std::size_t>(rectangle.bottom()),
            narrow_cast<std::size_t>(rectangle.width()),
            narrow_cast<std::size_t>(rectangle.height()));
    }
 
    pixel_row<T> const operator[](std::size_t rowNr) const noexcept
    {
        return {_pixels + (rowNr * _stride), _width};
    }
 
    pixel_row<T> operator[](std::size_t rowNr) noexcept
    {
        return {_pixels + (rowNr * _stride), _width};
    }
 
    pixel_row<T> const at(std::size_t rowNr) const noexcept
    {
        hi_assert(rowNr < _height);
        return (*this)[rowNr];
    }
 
    pixel_row<T> at(std::size_t rowNr) noexcept
    {
        hi_assert(rowNr < _height);
        return (*this)[rowNr];
    }
 
private:
    T *_pixels;
 
    std::size_t _width;
 
    std::size_t _height;
 
    std::size_t _stride;
 
    bool _self_allocated;
};
 
template<typename T>
void copy(pixel_map<T> const &src, pixel_map<T> &dst) noexcept
{
    std::size_t width = std::min(src.width(), dst.width());
    std::size_t height = std::min(src.height(), dst.height());
 
    for (std::size_t y = 0; y != height; ++y) {
        hilet src_row = src[y];
        auto dst_row = dst[y];
        for (std::size_t x = 0; x != width; ++x) {
            dst_row[x] = src_row[x];
        }
    }
}
 
template<int KERNEL_SIZE, typename KERNEL>
void horizontalFilterRow(pixel_row<uint8_t> row, KERNEL kernel) noexcept;
 
template<int KERNEL_SIZE, typename T, typename KERNEL>
void horizontalFilter(pixel_map<T> &pixels, KERNEL kernel) noexcept;
 
template<typename T>
void fill(pixel_map<T> &dst) noexcept;
 
template<typename T>
void fill(pixel_map<T> &dst, T color) noexcept;
 
template<typename T>
void rotate90(pixel_map<T> &dst, pixel_map<T> const &src) noexcept;
 
template<typename T>
void rotate270(pixel_map<T> &dst, pixel_map<T> const &src) noexcept;
 
void mergeMaximum(pixel_map<uint8_t> &dst, pixel_map<uint8_t> const &src) noexcept;
 
template<typename T>
inline void makeTransparentBorder(pixel_map<T> &pixel_map) noexcept;
 
} // namespace hi::inline v1