image.h

//-*- c++ -*-
//                                                                      //
//  CVD::image.h                                                        //
//                                                                      //
//  Definitions for of template class CVD::Image, fast_image        //
//                                                                      //
//  derived from IPRS_* developed by Tom Drummond                       //
//  Reworked to provide class heirachy and memory managementby E. Rosten//
//                                                                      //

#ifndef CVD_IMAGE_H
#define CVD_IMAGE_H

#include <cstring>
#include <cvd/exceptions.h>
#include <cvd/image_ref.h>
#include <iterator>
#include <string>
#include <type_traits>
#include <utility>

namespace CVD
{

namespace Exceptions
{

    namespace Image
    {
        struct All : public CVD::Exceptions::All
        {
            using CVD::Exceptions::All::All;
        };

        struct IncompatibleImageSizes : public All
        {
            IncompatibleImageSizes(const std::string& function)
                : All("Incompatible image sizes in " + function) {};
        };

        struct ImageRefNotInImage : public All
        {
            ImageRefNotInImage(const std::string& function)
                : All("Input ImageRefs not in image in " + function) {};
        };
    }
}

#ifndef DOXYGEN_IGNORE_INTERNAL
namespace Internal
{
    template <class C>
    struct ImagePromise
    {
    };

    [[noreturn]] void error_abort(const char* f, int l, const char* code);
};
#endif

#ifdef CVD_DEBUG
#define CVD_ASSERT(X)                                           \
    do                                                          \
    {                                                           \
        if(!(X))                                                \
            CVD::Internal::error_abort(__FILE__, __LINE__, #X); \
    } while(0)
#elif defined(_MSC_VER)
#define CVD_ASSERT(X) __assume(X)
#elif defined(__GNUC__) || defined(__clang__)
#define CVD_ASSERT(X)                \
    do                               \
    {                                \
        if(!(X))                     \
            __builtin_unreachable(); \
    } while(0)
#elif
#define CVD_ASSERT(X) \
    do                \
    {                 \
    } while(0)
#endif

#ifdef CVD_IMAGE_DEBUG
#define CVD_IMAGE_ASSERT(X, Y) \
    if(!(X))                   \
    throw Y()
#define CVD_IMAGE_ASSERT2(X, Y, Z) \
    if(!(X))                       \
    throw Y(Z)
#else
#define CVD_IMAGE_ASSERT(X, Y)
#define CVD_IMAGE_ASSERT2(X, Y, Z)
#endif

namespace ImageError
{
    class AccessOutsideImage
    {
    };
}

namespace Internal
{
    template <class T>
    inline void memfill(T* data, int n, const T val)
    {
        T* de = data + n;
        for(; data < de; data++)
            *data = val;
    }

    template <>
    inline void memfill(unsigned char* data, int n, const unsigned char val)
    {
        memset(data, val, n);
    }

    template <>
    inline void memfill(signed char* data, int n, const signed char val)
    {
        memset(data, val, n);
    }

    template <>
    inline void memfill(char* data, int n, const char val)
    {
        memset(data, val, n);
    }

    //Detecting a typedef...
    template <class C>
    struct IsDummy
    {
        //Fake function to pretend to return an instance of a type
        template <class S>
        static const C& get();

        //Two typedefs guaranteed to have different sizes
        typedef char One[1];
        typedef char Two[2];

        //Class to give us a size 2 return value or fail on
        //substituting S
        template <unsigned long S>
        struct SFINAE_dummy
        {
            typedef Two Type;
        };

        static One& detect_dummy(...);

        template <class S>
        static typename SFINAE_dummy<sizeof(typename S::dummy)>::Type& detect_dummy(const S&);

        static const bool Is = (sizeof(detect_dummy(get<C>())) == 2);
    };
}

template <class T>
class BasicImageIterator
{
    public:
    //Make it look like a standard iterator
    typedef std::forward_iterator_tag iterator_category;
    typedef T value_type;
    typedef std::ptrdiff_t difference_type;
    typedef T* pointer;
    typedef T& reference;

    const BasicImageIterator& operator++()
    {
        ptr++;
        if(ptr == row_end)
        {
            ptr += row_increment;
            row_end += total_width;

            if(ptr >= end)
                end = NULL;
        }
        return *this;
    }

    void operator++(int)
    {
        operator++();
    }

    T* operator->() const { return ptr; }
    T& operator*() const { return *ptr; }

    bool operator<(const BasicImageIterator& s) const
    {
        //It's illegal to iterate _past_ end(), so < is equivalent to !=
        //for end iterators.
        if(is_end && s.is_end)
            return 0;
        else if(is_end)
            return s.end != NULL;
        else if(s.is_end)
            return end != NULL;
        else
            return ptr < s.ptr;
    }

    bool operator==(const BasicImageIterator& s) const
    {
        return !((*this) != s);
    }

    bool operator!=(const BasicImageIterator& s) const
    {
        if(is_end && s.is_end)
            return 0;
        else if(is_end)
            return s.end != NULL;
        else if(s.is_end)
            return end != NULL;
        else
            return ptr != s.ptr;
    }

    BasicImageIterator()
    {
    }

    BasicImageIterator(T* start, int image_width, int row_stride, T* off_end)
        : ptr(start)
        , row_end(start + image_width)
        , end(off_end)
        , is_end(0)
        , row_increment(row_stride - image_width)
        , total_width(row_stride)
    {
    }

    //Prevent automatic conversion from a pointer (ie Image::iterator)
    explicit BasicImageIterator(T* endptr)
        : ptr(endptr)
        , is_end(1)
        , row_increment(0)
        , total_width(0)
    {
    }

    protected:
    T* ptr;
    T *row_end, *end;
    bool is_end;
    int row_increment, total_width;
};

template <class C>
class BasicImage;
template <class C>
using SubImage = BasicImage<C>;

namespace Internal
{

    //The structure is a little funny. We use inheritance here as a way of conditional
    //namespacing. So think of it like that not subclassing :)
    //
    //Essentially there are two image "types". One is an image of pixels, and includes
    //all the per-pixel types like byte, Rgb<byte> float, etc. These have the properties
    //that there is precisely one element per pixel. That makes pixel access obvious and
    //straightforward, so slicing (sub images) works fine and so on. Types need not be POD
    //
    //The other type is for images of crud. This includes yuv422, yuv420p and MJPEG. These
    //have no easy way of accessing pixels in general and no wasy way of creating sub images.
    //Technically, the types like YUV422 can be sub-imaged and have strides, but I've got no
    //use case for that and no one wants it.
    //
    //Silly types have a typedef called "dummy" because they're a placeholder and so don't
    //actually represent the underlying data.
    //
    //Dummy types are usually of fixed size (e.g. yuv types) and so the size is/should be known
    //at compile time. In this case, the dummy struct must provide a std::ratio called bytes_per_pixel

    //This is the image data holder for silly types lilke
    template <class T, bool D = Internal::IsDummy<T>::Is>
    class ImageData
    {
        public:
        ImageData(const ImageData&) = default;
        ImageData& operator=(const ImageData&) = default;

        ImageData(void* data, size_t len, ImageRef sz)
            : my_data(data)
            , my_size(sz)
            , data_length(len)
        {
        }

        ImageData(void* data, ImageRef sz)
            : my_data(data)
            , my_size(sz)
            , data_length(T::bytes_per_pixel::num * sz.area() / T::bytes_per_pixel::den)
        {
        }

        inline size_t datalength() const
        {
            return data_length;
        }

        ImageData()
        {
            my_data = 0;
            my_size = ImageRef(0, 0);
            data_length = 0;
        }

        protected:
        void* my_data;
        ImageRef my_size;
        size_t data_length;

        using PointerType = void*;
        using ConstPointerType = const void*;
    };

    template <class T>
    class ImageData<T, false>
    {
        public:
        ImageData(T* data, const ImageRef& size)
            : my_data(data)
            , my_size(size)
            , my_stride(size.x)
        {
        }

        ImageData(T* data, const ImageRef& size, int stride)
            : my_data(data)
            , my_size(size)
            , my_stride(stride)
        {
        }

        //We need them here in order to provide the functionality for
        //the asserts below. Technically they can apply to dummy types but
        //why bother?

        bool in_image(const ImageRef& ir) const
        {
            return ir.x >= 0 && ir.y >= 0 && ir.x < my_size.x && ir.y < my_size.y;
        }

        bool in_image_with_border(const ImageRef& ir, int border) const
        {
            return ir.x >= border && ir.y >= border && ir.x < my_size.x - border && ir.y < my_size.y - border;
        }

        inline T& operator[](const ImageRef& pos)
        {
            CVD_IMAGE_ASSERT(in_image(pos), ImageError::AccessOutsideImage);
            return (my_data[pos.y * my_stride + pos.x]);
        }

        inline const T& operator[](const ImageRef& pos) const
        {
            CVD_IMAGE_ASSERT(in_image(pos), ImageError::AccessOutsideImage);
            return (my_data[pos.y * my_stride + pos.x]);
        }

        inline T* operator[](int row)
        {
            CVD_IMAGE_ASSERT(in_image(ImageRef(0, row)), ImageError::AccessOutsideImage);
            return my_data + row * my_stride;
        }

        inline const T* operator[](int row) const
        {
            CVD_IMAGE_ASSERT(in_image(ImageRef(0, row)), ImageError::AccessOutsideImage);
            return my_data + row * my_stride;
        }

        inline ImageRef pos(const T* ptr) const
        {
            int diff = ptr - my_data;
            return ImageRef(diff % my_stride, diff / my_size.x);
        }

        typedef BasicImageIterator<T> iterator;
        typedef BasicImageIterator<const T> const_iterator;

        typedef T value_type;

        inline iterator begin()
        {
            return BasicImageIterator<T>(my_data, my_size.x, my_stride, end_ptr());
        }
        inline const_iterator begin() const
        {
            return BasicImageIterator<const T>(my_data, my_size.x, my_stride, end_ptr());
        }

        inline iterator end()
        {
            //Operator [] would always throw here!
            return BasicImageIterator<T>(end_ptr());
        }
        inline const_iterator end() const
        {
            //Operator [] would always throw here!
            return BasicImageIterator<const T>(end_ptr());
        }

        inline int row_stride() const
        {
            return my_stride;
        }

        BasicImage<T> sub_image(const ImageRef& start, const ImageRef& size);

        const BasicImage<T> sub_image(const ImageRef& start, const ImageRef& size) const;

        ImageData(const ImageData&) = default;
        ImageData& operator=(const ImageData&) = default;

        ImageData()
        {
            my_data = nullptr;
            my_size = ImageRef(0, 0);
            my_stride = 0;
        }

        protected:
        T* end_ptr() { return my_data + my_size.y * my_stride; }

        const T* end_ptr() const { return my_data + my_size.y * my_stride; }

        T* my_data;
        ImageRef my_size;
        int my_stride;
        using PointerType = T*;
        using ConstPointerType = const T*;
    };

}

template <class T>
class BasicImage : public Internal::ImageData<T>
{
    static const bool IsDummy = Internal::IsDummy<T>::Is;

    protected:
    using Internal::ImageData<T>::my_size;
    using Internal::ImageData<T>::my_data;
    using typename Internal::ImageData<T>::PointerType;
    using typename Internal::ImageData<T>::ConstPointerType;

    public:
    //Inherit all constructors
    using Internal::ImageData<T>::ImageData;

    virtual ~BasicImage()
    {
    }

    inline ConstPointerType data() const
    {
        return my_data;
    }

    inline PointerType data()
    {
        return my_data;
    }

    inline void copy_from(const BasicImage<T>& other)
    {
        CVD_IMAGE_ASSERT2(other.size() == this->size(), Exceptions::Image::IncompatibleImageSizes, "copy_from");
        for(int y = 0; y < my_size.y; y++)
            if constexpr(std::is_trivially_copyable_v<T>)
                std::memcpy((*this)[y], other[y], sizeof(T) * my_size.x);
            else
                std::copy(other[y], other[y] + my_size.x, (*this)[y]);
    }

    inline ImageRef size() const
    {
        return my_size;
    }

    inline void zero()
    {
        static_assert(std::is_trivially_copyable<T>::value, "Error: zero() only works on POD types");
        for(int y = 0; y < my_size.y; y++)
            memset((*this)[y], 0, sizeof(T) * my_size.x);
    }

    inline void fill(const T d)
    {
        for(int y = 0; y < my_size.y; y++)
            Internal::memfill((*this)[y], my_size.x, d);
    }

    BasicImage(const BasicImage& copyof) = default;

    BasicImage& operator=(const BasicImage& copyof) = default;

    protected:
    BasicImage() = default;
};

template <class C>
BasicImage<C> Internal::ImageData<C, false>::sub_image(const ImageRef& start, const ImageRef& size)
{
    CVD_IMAGE_ASSERT(in_image(start), ImageError::AccessOutsideImage);
    CVD_IMAGE_ASSERT(in_image(start + size - ImageRef(1, 1)), ImageError::AccessOutsideImage);
    return BasicImage<C>(&operator[](start), size, my_stride);
}

template <class C>
const BasicImage<C> Internal::ImageData<C, false>::sub_image(const ImageRef& start, const ImageRef& size) const
{
    CVD_IMAGE_ASSERT(in_image(start), ImageError::AccessOutsideImage);
    CVD_IMAGE_ASSERT(in_image(start + size - ImageRef(1, 1)), ImageError::AccessOutsideImage);

    C* ptr = my_data + start.y * my_stride + start.x;
    return BasicImage<C>(ptr, size, my_stride);
}

template <class T>
class Image : public SubImage<T>
{
    private:
    struct CopyPlaceHolder
    {
        const Image* im;
    };

    using SubImage<T>::my_size;
    //using SubImage<T>::my_stride;
    using SubImage<T>::my_data;

    public:
    typedef T value_type;

    inline Image& copy_from(const SubImage<T>& other)
    {
        resize(other.size());
        SubImage<T>::copy_from(other);
        return *this;
    }

    Image(const SubImage<T>& i)
        : Image(i.size())
    {
        copy_from(i);
    }

    Image(const Image& i)
        : Image(i.size())
    {
        copy_from(i);
    }

    Image(Image&& move_from)
    {
        static_cast<Internal::ImageData<T>&>(*this) = move_from;
        move_from.erase_fields();
    }

    Image& operator=(const Image& i)
    {
        resize(i.size());
        copy_from(i);
        return *this;
    }

    Image& operator=(Image&& move_from)
    {
        if(this != &move_from)
        {
            delete_old();
            static_cast<Internal::ImageData<T>&>(*this) = move_from;
            move_from.erase_fields();
        }

        return *this;
    }

#ifndef DOXYGEN_IGNORE_INTERNAL
    template <class C>
    const Image& operator=(Internal::ImagePromise<C> p)
    {
        p.execute(*this);
        return *this;
    }

    template <class C>
    Image(Internal::ImagePromise<C> p)
        : SubImage<T>()
    {
        p.execute(*this);
    }
#endif

    Image()
    {

        erase_fields();
    }

    Image(const ImageRef& size)
    {
        resize(size);
    }

    Image(const ImageRef& size, const T& val)
    {
        resize(size);
        this->fill(val);
    }

    void resize(const ImageRef& size)
    {
        resize_(size, DD<Internal::IsDummy<T>::Is> {});
    }

    //The resized image is filled with val.
    void resize(const ImageRef& size, const T& val)
    {
        resize(size);
        fill(val);
    }

    ~Image()
    {
        delete_old();
    }

    private:
    void delete_old()
    {
        delete_(DD<Internal::IsDummy<T>::Is> {});
        erase_fields();
    }

    void erase_fields()
    {
        static_cast<Internal::ImageData<T>&>(*this) = Internal::ImageData<T>();
    }

    //Allow type switching on dummy data: the internals are quite different
    //for dummy types.
    template <int Dummy>
    struct DD
    {
    };

    template <int Dummy>
    void resize_(const ImageRef& size, DD<Dummy>)
    {
        if(size == ImageRef(0, 0))
        {
            delete_old();
        }
        else if(size != BasicImage<T>::my_size)
        {
            delete_old();
            static_cast<BasicImage<T>&>(*this) = BasicImage<T>(new T[size.area()], size);
        }
    }

    void resize_(const ImageRef& size, DD<true>)
    {
        if(size == ImageRef(0, 0))
        {
            delete_old();
        }
        else if(size != BasicImage<T>::my_size)
        {
            delete_old();
            static_cast<BasicImage<T>&>(*this) = BasicImage<T>(nullptr, size);
            my_data = new char[this->datalength()];
        }
    }

    template <int Dummy>
    void delete_(DD<Dummy>)
    {
        delete[] my_data;
    }

    void delete_(DD<true>)
    {
        delete[] static_cast<char*>(my_data);
    }
};

} // end namespace
#endif