Views/Image.hpp

Go to the documentation of this file.

 
#ifndef LLU_CONTAINERS_VIEWS_IMAGE_HPP
#define LLU_CONTAINERS_VIEWS_IMAGE_HPP
 
#include "LLU/Containers/Generic/Image.hpp"
#include "LLU/Containers/Interfaces.h"
#include "LLU/Containers/Iterators/IterableContainer.hpp"
#include "LLU/ErrorLog/ErrorManager.h"
 
namespace LLU {
 
    class ImageView : public ImageInterface {
    public:
        ImageView() = default;
 
        ImageView(const GenericImage& gIm) : m {gIm.getContainer()} {}    // NOLINT: implicit conversion to a view is useful and harmless
 
        ImageView(MImage mi) : m {mi} {}    // NOLINT
 
        colorspace_t colorspace() const override {
            return LibraryData::ImageAPI()->MImage_getColorSpace(m);
        }
 
        mint rows() const override {
            return LibraryData::ImageAPI()->MImage_getRowCount(m);
        }
 
        mint columns() const override {
            return LibraryData::ImageAPI()->MImage_getColumnCount(m);
        }
 
        mint slices() const override {
            return LibraryData::ImageAPI()->MImage_getSliceCount(m);
        }
 
        mint channels() const override {
            return LibraryData::ImageAPI()->MImage_getChannels(m);
        }
 
        bool alphaChannelQ() const override {
            return LibraryData::ImageAPI()->MImage_alphaChannelQ(m) == True;
        }
 
        bool interleavedQ() const override {
            return LibraryData::ImageAPI()->MImage_interleavedQ(m) == True;
        }
 
        bool is3D() const override {
            return LibraryData::ImageAPI()->MImage_getRank(m) == 3;
        }
 
        mint getRank() const override {
            return LibraryData::ImageAPI()->MImage_getRank(m);
        }
 
        mint getFlattenedLength() const override {
            return LibraryData::ImageAPI()->MImage_getFlattenedLength(m);
        }
 
        imagedata_t type() const final {
            return LibraryData::ImageAPI()->MImage_getDataType(m);
        }
 
        void* rawData() const override {
            return LibraryData::ImageAPI()->MImage_getRawData(m);
        }
 
    private:
        MImage m = nullptr;
    };
 
    template<typename T>
    class ImageTypedView : public ImageView, public IterableContainer<T> {
    public:
        ImageTypedView() = default;
 
        ImageTypedView(const GenericImage& gIm) : ImageView(gIm) {    // NOLINT: implicit conversion to a view is useful and harmless
            if (ImageType<T> != type()) {
                ErrorManager::throwException(ErrorName::ImageTypeError);
            }
        }
 
        ImageTypedView(ImageView iv) : ImageView(std::move(iv)) {    // NOLINT
            if (ImageType<T> != type()) {
                ErrorManager::throwException(ErrorName::ImageTypeError);
            }
        }
 
        ImageTypedView(MImage mi) : ImageView(mi) {    // NOLINT
            if (ImageType<T> != type()) {
                ErrorManager::throwException(ErrorName::ImageTypeError);
            }
        }
 
    private:
        T* getData() const noexcept override {
            return static_cast<T*>(rawData());
        }
 
        mint getSize() const noexcept override {
            return getFlattenedLength();
        }
    };
 
    template<typename ImageT, typename F>
    auto asTypedImage(ImageT&& img, F&& callable) {
        switch (img.type()) {
            case MImage_Type_Bit: return std::forward<F>(callable)(ImageTypedView<std::int8_t>(std::forward<ImageT>(img)));
            case MImage_Type_Bit8: return std::forward<F>(callable)(ImageTypedView<std::uint8_t>(std::forward<ImageT>(img)));
            case MImage_Type_Bit16: return std::forward<F>(callable)(ImageTypedView<std::uint16_t>(std::forward<ImageT>(img)));
            case MImage_Type_Real32: return std::forward<F>(callable)(ImageTypedView<float>(std::forward<ImageT>(img)));
            case MImage_Type_Real: return std::forward<F>(callable)(ImageTypedView<double>(std::forward<ImageT>(img)));
            default: ErrorManager::throwException(ErrorName::ImageTypeError);
        }
    }
 
    // Specialization of asTypedImage for MImage
    template<typename F>
    auto asTypedImage(MImage img, F&& callable) {
        return asTypedImage(ImageView {img}, std::forward<F>(callable));
    }
}  // namespace LLU
 
#endif    // LLU_CONTAINERS_VIEWS_IMAGE_HPP