PixelMap.hpp

// Copyright 2019 Pokitec
// All rights reserved.
 
#pragma once
 
#include "TTauri/Foundation/required.hpp"
#include "TTauri/Foundation/iaarect.hpp"
#include <nonstd/span>
#include <string>
#include <algorithm>
#include <vector>
 
namespace tt {
 
template <typename T>
struct PixelRow {
    T *pixels;
 
    ssize_t width;
 
    T const *data() const noexcept {
        return pixels;
    }
 
    T *data() noexcept {
        return pixels;
    }
 
    T const &operator[](ssize_t columnNr) const noexcept {
        return pixels[columnNr];
    }
 
    T &operator[](ssize_t columnNr) noexcept {
        return pixels[columnNr];
    }
 
    T const &at(ssize_t columnNr) const noexcept {
        tt_assert(columnNr >= 0 && columnNr < width);
        return pixels[columnNr];
    }
 
    T &at(ssize_t columnNr) noexcept {
        tt_assert(columnNr >= 0 && columnNr < width);
        return pixels[columnNr];
    }
};
 
template <typename T>
struct PixelMap {
    T *pixels;
 
    ssize_t width;
 
    ssize_t height;
 
    ssize_t stride;
 
    bool selfAllocated = false;
 
    PixelMap() noexcept : pixels(nullptr), width(0), height(0), stride(0) {}
 
    PixelMap(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);
        }
    } 
 
    gsl_suppress(r.11)
    PixelMap(ssize_t width, ssize_t height) noexcept : pixels(new T[width * height]), width(width), height(height), stride(width), selfAllocated(true) {
        if (pixels) {
            tt_assert(stride >= width);
            tt_assert(width > 0);
            tt_assert(height > 0);
        } else {
            tt_assert(width == 0);
            tt_assert(height == 0);
        }
    }
 
    PixelMap(ivec extent) noexcept : PixelMap(extent.x(), extent.y()) {}
 
    PixelMap(T *pixels, ssize_t width, ssize_t height) noexcept : PixelMap(pixels, width, height, width) {}
 
    PixelMap(T *pixels, ivec extent) noexcept : PixelMap(pixels, extent.x(), extent.y()) {}
 
    PixelMap(T *pixels, ivec extent, ssize_t stride) noexcept : PixelMap(pixels, extent.x(), extent.y(), stride) {}
 
    gsl_suppress2(r.11,i.11)
    ~PixelMap() {
        if (selfAllocated) {
            delete[] pixels;
        }
    }
 
    PixelMap(PixelMap const &other) = delete;
 
    PixelMap copy() const noexcept {
        if (selfAllocated) {
            auto r = PixelMap(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);
        }
    }
 
    PixelMap(PixelMap &&other) noexcept : pixels(other.pixels), width(other.width), height(other.height), stride(other.stride), selfAllocated(other.selfAllocated) {
        tt_assume(this != &other);
        other.selfAllocated = false;
    }
 
    operator bool() const noexcept {
        return pixels;
    }
 
    PixelMap &operator=(PixelMap const &other) = delete;
 
    gsl_suppress2(r.11,i.11)
    PixelMap &operator=(PixelMap &&other) noexcept {
        // Compatible with self-move.
        if (selfAllocated) {
            delete[] pixels;
        }
        pixels = other.pixels;
        width = other.width;
        height = other.height;
        stride = other.stride;
        selfAllocated = other.selfAllocated;
        other.selfAllocated = false;
        return *this;
    }
 
    ivec extent() const noexcept {
        return {width, height};
    }
 
    PixelMap<T> submap(iaarect rect) const noexcept {
        tt_assert(
            (rect.x1() >= 0) &&
            (rect.y2() >= 0) &&
            (rect.width() >= 0) &&
            (rect.height() >= 0)
        );
        tt_assert(
            (rect.x2() <= width) &&
            (rect.y2() <= height)
        );
 
        ttlet offset = rect.y1() * stride + rect.x1();
 
        return { pixels + offset, rect.width(), rect.height(), stride };
    }
    
    PixelMap<T> submap(ssize_t x, ssize_t y, ssize_t _width, ssize_t _height) const noexcept {
        return submap(iaarect{x, y, _width, _height});
    }
 
    PixelRow<T> const operator[](ssize_t rowNr) const noexcept {
        return { pixels + (rowNr * stride), width };
    }
 
    PixelRow<T> operator[](ssize_t rowNr) noexcept {
        return { pixels + (rowNr * stride), width };
    }
 
    PixelRow<T> const at(ssize_t rowNr) const noexcept {
        tt_assert(rowNr < height);
        return (*this)[rowNr];
    }
 
    PixelRow<T> at(ssize_t rowNr) noexcept {
        tt_assert(rowNr < height);
        return (*this)[rowNr];
    }
};
 
template<typename T>
void copy(PixelMap<T> const &src, PixelMap<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(PixelRow<uint8_t> row, KERNEL kernel) noexcept;
 
template<int KERNEL_SIZE, typename T, typename KERNEL>
void horizontalFilter(PixelMap<T>& pixels, KERNEL kernel) noexcept;
 
template<typename T>
void fill(PixelMap<T> &dst) noexcept;
 
template<typename T>
void fill(PixelMap<T> &dst, T color) noexcept;
 
template<typename T>
void rotate90(PixelMap<T> &dst, PixelMap<T> const &src) noexcept;
 
template<typename T>
void rotate270(PixelMap<T> &dst, PixelMap<T> const &src) noexcept;
 
void mergeMaximum(PixelMap<uint8_t> &dst, PixelMap<uint8_t> const &src) noexcept;
 
template<typename T>
inline void makeTransparentBorder(PixelMap<T> & pixelMap) noexcept;
 
}