Image.hpp

Go to the documentation of this file.

#pragma once
 
#include <memory>
#include <cstdint>
#include <cstddef>
#include <algorithm>
#include <utility>
#include <cstdlib>
#include <limits>
#include <stdexcept>
 
#include "Common.hpp"
#include "Contract.hpp"
 
namespace mmcfilters {
 
namespace detail {
class CommittedImageAccess;
}
 
template <typename PixelType> class Image {
  private:
    friend class detail::CommittedImageAccess;
    struct EstablishedDimensionsTag {};
    int numRows;
    int numColumns;
    std::shared_ptr<PixelType[]> data;
    using Ptr = std::shared_ptr<Image<PixelType>>;
 
    static std::size_t checkedSize(int rows, int columns) {
        MMCFILTERS_CONTRACT_REQUIRE(rows > 0 && columns > 0, throw std::invalid_argument("Image dimensions must be positive."));
        const auto rowCount = static_cast<std::size_t>(rows);
        const auto columnCount = static_cast<std::size_t>(columns);
        MMCFILTERS_CONTRACT_REQUIRE(rowCount <= static_cast<std::size_t>(std::numeric_limits<int>::max()) / columnCount,
                                    throw std::overflow_error("Image dimensions exceed the supported int-indexed size."));
        return rowCount * columnCount;
    }
 
    Image(int rows, int columns, [[maybe_unused]] EstablishedDimensionsTag tag)
        : numRows(rows), numColumns(columns),
          data(new PixelType[static_cast<std::size_t>(rows) * static_cast<std::size_t>(columns)], [](PixelType* pixels) { delete[] pixels; }) {}
 
  public:
    using Type = PixelType;
 
    Image(int rows, int columns) : numRows(rows), numColumns(columns), data(new PixelType[checkedSize(rows, columns)], [](PixelType* pixels) { delete[] pixels; }) {}
 
    [[nodiscard]] static Ptr create(int rows, int columns) { return std::make_shared<Image>(rows, columns); }
 
    [[nodiscard]] static Ptr create(int rows, int columns, PixelType initValue) {
        auto img = create(rows, columns);
        img->fill(initValue);
        return img;
    }
 
    [[nodiscard]] static Ptr fromExternal(PixelType* rawPtr, int rows, int columns) {
        MMCFILTERS_CONTRACT_REQUIRE(rawPtr != nullptr, throw std::invalid_argument("Image::fromExternal requires a non-null raw pointer."));
        auto img = create(rows, columns);
        img->data = std::shared_ptr<PixelType[]>(rawPtr, [](PixelType*) {
            // Empty deleter: the wrapper does not release external memory.
        });
        return img;
    }
 
    [[nodiscard]] static Ptr fromRaw(PixelType* rawPtr, int rows, int columns) {
        MMCFILTERS_CONTRACT_REQUIRE(rawPtr != nullptr, throw std::invalid_argument("Image::fromRaw requires a non-null raw pointer."));
        auto img = create(rows, columns);
        img->data = std::shared_ptr<PixelType[]>(rawPtr, [](PixelType* pixels) { delete[] pixels; });
        return img;
    }
 
    void fill(PixelType value) { std::fill_n(data.get(), numRows * numColumns, value); }
 
    bool isEqual(const Ptr& other) const {
        if (numRows != other->numRows || numColumns != other->numColumns)
            return false;
        int n = numRows * numColumns;
        for (int i = 0; i < n; ++i) {
            if (data[i] != (*other)[i])
                return false;
        }
        return true;
    }
 
    [[nodiscard]] Ptr clone() const {
        auto newImg = create(numRows, numColumns);
        std::copy(data.get(), data.get() + (numRows * numColumns), newImg->data.get());
        return newImg;
    }
 
    std::shared_ptr<PixelType[]> rawDataPtr() { return data; }
 
    PixelType* rawData() { return data.get(); }
 
    int getNumRows() const { return numRows; }
 
    int getNumColumns() const { return numColumns; }
 
    int getSize() const { return numRows * numColumns; }
 
    PixelType& operator[](PixelId index) { return data[index]; }
 
    const PixelType& operator[](PixelId index) const { return data[index]; }
};
 
using ImageUInt8 = Image<uint8_t>;
using ImageInt32 = Image<int32_t>;
using ImageFloat = Image<float>;
 
using ImageUInt8Ptr = std::shared_ptr<ImageUInt8>;
using ImageInt32Ptr = std::shared_ptr<ImageInt32>;
using ImageFloatPtr = std::shared_ptr<ImageFloat>;
 
template <typename PixelType> using ImagePtr = std::shared_ptr<Image<PixelType>>;
 
class ImageUtils {
  public:
    inline static PixelId to1D(int row, int column, int numColumns) noexcept { return row * numColumns + column; }
 
    inline static std::pair<int, int> to2D(PixelId index, int numColumns) noexcept {
        int row = index / numColumns;
        int column = index - row * numColumns;
        return {row, column};
    }
 
    [[nodiscard]] static ImageUInt8Ptr createRandomColor(int* img, int numRowsOfImage, int numColumnsOfImage) {
        int max = 0;
        int sizeImage = numColumnsOfImage * numRowsOfImage;
        for (int i = 0; i < sizeImage; i++) {
            if (img[i] > max)
                max = img[i];
        }
 
        std::unique_ptr<int[]> r(new int[max + 1]);
        std::unique_ptr<int[]> g(new int[max + 1]);
        std::unique_ptr<int[]> b(new int[max + 1]);
        r[0] = 0;
        g[0] = 0;
        r[0] = 0;
        for (int i = 1; i <= max; i++) {
            r[i] = rand() % 256;
            g[i] = rand() % 256;
            b[i] = rand() % 256;
        }
 
        int sizeOutput = sizeImage * 3; // [(R,G,B), (R,G,B), ...]
        ImageUInt8Ptr outImage = ImageUInt8::create(numRowsOfImage, numColumnsOfImage * 3);
 
        auto output = outImage->rawData();
        // Initialise with zero.
        std::fill_n(output, sizeOutput, 0);
 
        for (int pidx = 0; pidx < sizeImage; pidx++) {
            int cpidx = pidx * 3; // (coloured) for 3 channels
            output[cpidx] = r[img[pidx]];
            output[cpidx + 1] = g[img[pidx]];
            output[cpidx + 2] = b[img[pidx]];
        }
        return outImage;
    }
};
 
} // namespace mmcfilters