Image.h

Go to the documentation of this file.

 
#ifndef LLU_CONTAINERS_IMAGE_H_
#define LLU_CONTAINERS_IMAGE_H_
 
#include <array>
 
#include "LLU/Containers/Generic/Image.hpp"
#include "LLU/Containers/MArray.hpp"
 
namespace LLU {
 
    template<typename T>
    class TypedImage : public MArray<T> {
    public:
        using MArray<T>::MArray;
 
        T get(mint row, mint col, mint channel) const {
            std::array<mint, 2> pos {{row, col}};
            return getValueAt(pos.data(), channel);
        }
 
        T get(mint slice, mint row, mint col, mint channel) const {
            std::array<mint, 3> pos {{slice, row, col}};
            return getValueAt(pos.data(), channel);
        }
 
        void set(mint row, mint col, mint channel, T newValue) {
            std::array<mint, 2> pos {{row, col}};
            setValueAt(pos.data(), channel, newValue);
        }
 
        void set(mint slice, mint row, mint col, mint channel, T newValue) {
            std::array<mint, 3> pos {{slice, row, col}};
            setValueAt(pos.data(), channel, newValue);
        }
 
    private:
        T* getData() const noexcept override {
            return static_cast<T*>(LibraryData::ImageAPI()->MImage_getRawData(this->getInternal()));
        }
 
        virtual MImage getInternal() const = 0;
 
        [[noreturn]] void indexError() const {
            ErrorManager::throwException(ErrorName::ImageIndexError);
        }
 
        T getValueAt(mint* pos, mint channel) const;
 
        void setValueAt(mint* pos, mint channel, T newValue);
    };
 
    template<typename T>
    class Image : public TypedImage<T>, public GenericImage {
    public:
        Image(mint w, mint h, mint channels, colorspace_t cs, bool interleavingQ);
 
        Image(mint nFrames, mint w, mint h, mint channels, colorspace_t cs, bool interleavingQ);
 
        explicit Image(GenericImage im);
 
        Image(MImage mi, Ownership owner) : Image(GenericImage(mi, owner)) {};
 
        Image() = default;
 
        Image clone() const;
 
        template<typename U>
        Image<U> convert(bool interleaved) const;
 
        template<typename U>
        Image<U> convert() const;
 
    private:
        using GenericBase = GenericImage;
 
        MImage getInternal() const noexcept override {
            return this->getContainer();
        }
 
        [[noreturn]] static void sizeError() {
            ErrorManager::throwException(ErrorName::ImageSizeError);
        }
 
        static MArrayDimensions dimensionsFromGenericImage(const GenericBase& im);
    };
 
    template<typename T>
    Image<T>::Image(mint w, mint h, mint channels, colorspace_t cs, bool interleavingQ) : Image(0, w, h, channels, cs, interleavingQ) {}
 
    template<typename T>
    Image<T>::Image(GenericBase im) : TypedImage<T>(dimensionsFromGenericImage(im)), GenericBase(std::move(im)) {
        if (ImageType<T> != GenericBase::type()) {
            ErrorManager::throwException(ErrorName::ImageTypeError);
        }
    }
 
    template<typename T>
    Image<T>::Image(mint nFrames, mint w, mint h, mint channels, colorspace_t cs, bool interleavingQ)
        : Image(GenericBase {nFrames, w, h, channels, ImageType<T>, cs, interleavingQ}) {}
 
    template<typename T>
    Image<T> Image<T>::clone() const {
        return Image {cloneContainer(), Ownership::Library};
    }
 
    template<typename T>
    template<typename U>
    Image<U> Image<T>::convert(bool interleaved) const {
        return Image<U> {GenericImage::convert(ImageType<U>, interleaved)};
    }
 
    template<typename T>
    template<typename U>
    Image<U> Image<T>::convert() const {
        return convert<U>(interleavedQ());
    }
 
    template<typename T>
    MArrayDimensions Image<T>::dimensionsFromGenericImage(const GenericBase& im) {
        std::vector<mint> dims;
        if (!im.getContainer()) {
            return MArrayDimensions {dims};
        }
        mint depth = im.getRank() + (im.channels() == 1 ? 0 : 1);
        if (im.is3D()) {
            dims = {im.slices(), im.rows(), im.columns()};
        } else {
            dims = {im.rows(), im.columns()};
        }
        if (im.channels() > 1) {
            if (im.interleavedQ()) {
                dims.push_back(im.channels());
            } else {
                dims.insert(dims.begin(), im.channels());
            }
        }
        if (dims.size() != static_cast<std::make_unsigned_t<mint>>(depth)) {
            sizeError();
        }
        return MArrayDimensions {dims};
    }
} /* namespace LLU */
 
#endif /* LLU_CONTAINERS_IMAGE_H_ */