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 "aarect.hpp"
#include <span>
#include <string>
#include <algorithm>
#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) {}
 
    pixel_map(T *pixels, ssize_t width, ssize_t height, ssize_t stride) noexcept :
        _pixels(pixels), _width(width), _height(height), _stride(stride)
    {
        if (pixels) {
            tt_assert(_stride >= _width);
            tt_assert(_width > 0);
            tt_assert(_height > 0);
        } else {
            tt_assert(_width == 0);
            tt_assert(_height == 0);
        }
    }
 
    pixel_map(ssize_t width, ssize_t height) noexcept :
        _pixels(new T[width * height]), _width(width), _height(height), _stride(width), _self_allocated(true)
    {
        if (_pixels) {
            tt_assert(_stride >= _width);
            tt_assert(_width > 0);
            tt_assert(_height > 0);
        } else {
            tt_assert(_width == 0);
            tt_assert(_height == 0);
        }
    }
 
    pixel_map(i32x4 extent) noexcept : pixel_map(extent.x(), extent.y()) {}
 
    pixel_map(T *pixels, ssize_t width, ssize_t height) noexcept : pixel_map(pixels, width, height, width) {}
 
    pixel_map(T *pixels, i32x4 extent) noexcept : pixel_map(pixels, extent.x(), extent.y()) {}
 
    pixel_map(T *pixels, i32x4 extent, ssize_t stride) noexcept : pixel_map(pixels, extent.x(), extent.y(), stride) {}
 
    ~pixel_map()
    {
        if (_self_allocated) {
            delete[] _pixels;
        }
    }
 
    pixel_map(pixel_map const &other) = delete;
 
    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];
                }
            }
 
            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), _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;
    }
 
    pixel_map &operator=(pixel_map const &other) = delete;
 
    pixel_map &operator=(pixel_map &&other) noexcept
    {
        // Compatible with self-move.
        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;
    }
 
    i32x4 extent() const noexcept
    {
        return {narrow_cast<int>(_width), narrow_cast<int>(_height)};
    }
 
    pixel_map<T> submap(iaarect rect) const noexcept
    {
        tt_axiom((rect.left() >= 0) && (rect.bottom() >= 0));
        tt_assert((rect.right() <= _width) && (rect.top() <= _height));
 
        ttlet offset = rect.bottom() * _stride + rect.left();
 
        return {_pixels + offset, rect.width(), rect.height(), _stride};
    }
 
    pixel_map<T> submap(ssize_t x, ssize_t y, ssize_t width, ssize_t height) const noexcept
    {
        return submap(iaarect{x, y, width, 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];
    }
 
private:
    T *_pixels;
 
    ssize_t _width;
 
    ssize_t _height;
 
    ssize_t _stride;
 
    bool _self_allocated = false;
};
 
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