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 "hash.hpp"
#include "geometry/axis_aligned_rectangle.hpp"
#include "geometry/extent.hpp"
#include <algorithm>
#include <cassert>
#include <span>
#include <string>
#include <vector>
 
namespace tt {
 
template<typename T>
class pixel_row {
public:
    pixel_row(T *pixels, ssize_t width) noexcept : _pixels(pixels), _width(width) {}
 
    [[nodiscard]] ssize_t width() const noexcept
    {
        return _width;
    }
 
    [[nodiscard]] T const *data() const noexcept
    {
        return _pixels;
    }
 
    [[nodiscard]] T *data() noexcept
    {
        return _pixels;
    }
 
    [[nodiscard]] T const &operator[](ssize_t columnNr) const noexcept
    {
        return _pixels[columnNr];
    }
 
    [[nodiscard]] T &operator[](ssize_t columnNr) noexcept
    {
        return _pixels[columnNr];
    }
 
    [[nodiscard]] T const &at(ssize_t columnNr) const noexcept
    {
        tt_assert(columnNr >= 0 && columnNr < _width);
        return _pixels[columnNr];
    }
 
    [[nodiscard]] T &at(ssize_t columnNr) noexcept
    {
        tt_assert(columnNr >= 0 && columnNr < _width);
        return _pixels[columnNr];
    }
 
private:
    T *_pixels;
 
    ssize_t _width;
};
 
template<typename T>
class pixel_map {
public:
    pixel_map() noexcept : _pixels(nullptr), _width(0), _height(0), _stride(0), _hash(0), _self_allocated(true) {}
 
    pixel_map(T *pixels, ssize_t width, ssize_t height, ssize_t stride) noexcept :
        _pixels(pixels), _width(width), _height(height), _stride(stride), _hash(0), _self_allocated(false)
    {
        tt_assert(_stride >= _width);
        tt_assert(_width >= 0);
        tt_assert(_height >= 0);
 
        if (pixels == nullptr) {
            _self_allocated = true;
            _pixels = new T[_height * _stride];
        }
    }
 
    pixel_map(T *pixels, ssize_t width, ssize_t height) noexcept : pixel_map(pixels, width, height, width) {}
 
    pixel_map(ssize_t width, ssize_t height, ssize_t stride) noexcept : pixel_map(nullptr, width, height, stride) {}
 
    pixel_map(ssize_t width, ssize_t height) noexcept : pixel_map(nullptr, width, height, width) {}
 
    ~pixel_map()
    {
        if (_self_allocated) {
            delete[] _pixels;
        }
    }
 
    pixel_map(pixel_map const &other) = delete;
 
    [[nodiscard]] pixel_map copy() const noexcept
    {
        if (_self_allocated) {
            auto r = pixel_map(_width, _height);
 
            for (ssize_t y = 0; y != _height; ++y) {
                ttlet src_row = (*this)[y];
                auto dst_row = r[y];
                for (ssize_t x = 0; x != _width; ++x) {
                    dst_row[x] = src_row[x];
                }
            }
 
            r._hash = _hash;
            return r;
        } else {
            return submap(0, 0, _width, _height);
        }
    }
 
    pixel_map(pixel_map &&other) noexcept :
        _pixels(other._pixels),
        _width(other._width),
        _height(other._height),
        _stride(other._stride),
        _hash(other._hash),
        _self_allocated(other._self_allocated)
    {
        tt_axiom(this != &other);
        other._self_allocated = false;
    }
 
    [[nodiscard]] operator bool() const noexcept
    {
        return _pixels != nullptr;
    }
 
    [[nodiscard]] ssize_t width() const noexcept
    {
        return _width;
    }
 
    [[nodiscard]] ssize_t height() const noexcept
    {
        return _height;
    }
 
    [[nodiscard]] ssize_t stride() const noexcept
    {
        return _stride;
    }
 
    [[nodiscard]] size_t hash() const noexcept
    {
        return _hash;
    }
 
    pixel_map &operator=(pixel_map const &other) = delete;
 
    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;
        _hash = other._hash;
        _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(ssize_t x, ssize_t y, ssize_t width, ssize_t height) const noexcept
    {
        tt_axiom((x >= 0) && (y >= 0));
        tt_assert((x + width <= _width) && (y + height <= _height));
 
        ttlet offset = y * _stride + x;
 
        auto r = pixel_map{_pixels + offset, width, height, _stride};
        r._hash = (width == _width && height == _height) ? _hash : 0;
        return r;
    }
 
    pixel_map submap(aarectangle rectangle) const noexcept
    {
        tt_axiom(round(rectangle) == rectangle);
        return submap(
            narrow_cast<ssize_t>(rectangle.left()),
            narrow_cast<ssize_t>(rectangle.bottom()),
            narrow_cast<ssize_t>(rectangle.width()),
            narrow_cast<ssize_t>(rectangle.height()));
    }
 
    pixel_row<T> const operator[](ssize_t rowNr) const noexcept
    {
        return {_pixels + (rowNr * _stride), _width};
    }
 
    pixel_row<T> operator[](ssize_t rowNr) noexcept
    {
        return {_pixels + (rowNr * _stride), _width};
    }
 
    pixel_row<T> const at(ssize_t rowNr) const noexcept
    {
        tt_assert(rowNr < _height);
        return (*this)[rowNr];
    }
 
    pixel_row<T> at(ssize_t rowNr) noexcept
    {
        tt_assert(rowNr < _height);
        return (*this)[rowNr];
    }
 
    void update_hash() noexcept
    {
        size_t h = hash_mix(_width, _height);
        for (ssize_t row_nr = 0; row_nr != _height; ++row_nr) {
            ttlet &row = (*this)[row_nr];
            for (ssize_t col_nr = 0; col_nr != _width; ++col_nr) {
                h = hash_mix(h, row[col_nr]);
            }
        }
        _hash = h;
    }
 
private:
    T *_pixels;
 
    ssize_t _width;
 
    ssize_t _height;
 
    ssize_t _stride;
 
    size_t _hash;
 
    bool _self_allocated;
};
 
template<typename T>
void copy(pixel_map<T> const &src, pixel_map<T> &dst) noexcept
{
    ssize_t width = std::min(src.width(), dst.width());
    ssize_t height = std::min(src.height(), dst.height());
 
    for (ssize_t y = 0; y != height; ++y) {
        ttlet src_row = src[y];
        auto dst_row = dst[y];
        for (ssize_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 tt