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>
 
namespace mmcfilters {
 
template <typename PixelType>
class Image {
    private:
        int numRows;
        int numCols;
        std::shared_ptr<PixelType[]> data;
        using Ptr = std::shared_ptr<Image<PixelType>>;
 
        static std::size_t checkedSize(int rows, int cols) {
            if (rows <= 0 || cols <= 0) {
                throw std::invalid_argument("Image dimensions must be positive.");
            }
            const auto rowCount = static_cast<std::size_t>(rows);
            const auto colCount = static_cast<std::size_t>(cols);
            if (rowCount > static_cast<std::size_t>(std::numeric_limits<int>::max()) / colCount) {
                throw std::overflow_error("Image dimensions exceed the supported int-indexed size.");
            }
            return rowCount * colCount;
        }
        
    public:
    using Type = PixelType;
 
    Image(int rows, int cols): numRows(rows), numCols(cols), data(new PixelType[checkedSize(rows, cols)], std::default_delete<PixelType[]>()) {}
 
    [[nodiscard]] static Ptr create(int rows, int cols) {
        return std::make_shared<Image>(rows, cols);
    }
 
    [[nodiscard]] static Ptr create(int rows, int cols, PixelType initValue) {
        auto img = create(rows, cols);
        img->fill(initValue);
        return img;
    }
 
    [[nodiscard]] static Ptr fromExternal(PixelType* rawPtr, int rows, int cols) {
        if (rawPtr == nullptr) {
            throw std::invalid_argument("Image::fromExternal requires a non-null raw pointer.");
        }
        auto img = create(rows, cols);
        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 cols) {
        if (rawPtr == nullptr) {
            throw std::invalid_argument("Image::fromRaw requires a non-null raw pointer.");
        }
        auto img = create(rows, cols);
        img->data = std::shared_ptr<PixelType[]>(rawPtr, std::default_delete<PixelType[]>());
        return img;
    }
 
 
    void fill(PixelType value) {
        std::fill_n(data.get(), numRows * numCols, value);
    }
 
    bool isEqual(const Ptr& other) const {
        if (numRows != other->numRows || numCols != other->numCols)
            return false;
        int n = numRows * numCols;
        for (int i = 0; i < n; ++i) {
            if (data[i] != (*other)[i])
                return false;
        }
        return true;
    }
 
    [[nodiscard]] Ptr clone() const {
        auto newImg = create(numRows, numCols);
        std::copy(data.get(), data.get() + (numRows * numCols), newImg->data.get());
        return newImg;
    }
 
    std::shared_ptr<PixelType[]> rawDataPtr(){ return data; }
 
    PixelType* rawData() { return data.get(); }
 
    int getNumRows() const { return numRows; }
 
    int getNumCols() const { return numCols; }
 
    int getSize() const { return numRows * numCols; }
 
    PixelType& operator[](int index) { return data[index]; }
 
    const PixelType& operator[](int 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 int to1D(int row, int col, int numCols) noexcept{
        return row * numCols + col;
    }
 
    inline static std::pair<int, int> to2D(int index, int numCols) noexcept {
        int row = index / numCols;
        int col = index - row * numCols;
        return {row, col};
    }
 
    [[nodiscard]] static ImageUInt8Ptr createRandomColor(int* img, int numRowsOfImage, int numColsOfImage){
        int max = 0;
        int sizeImage = numColsOfImage * 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, numColsOfImage * 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;
    }
 
 
};
 
}