metafunctions.hpp

//
// Copyright 2005-2007 Adobe Systems Incorporated
// Copyright 2021 Pranam Lashkari <plashkari628@gmail.com>
//
// Distributed under the Boost Software License, Version 1.0
// See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt
//
#ifndef BOOST_GIL_METAFUNCTIONS_HPP
#define BOOST_GIL_METAFUNCTIONS_HPP
 
#include <boost/gil/channel.hpp>
#include <boost/gil/dynamic_step.hpp>
#include <boost/gil/concepts.hpp>
#include <boost/gil/concepts/detail/type_traits.hpp>
#include <boost/gil/detail/mp11.hpp>
 
#include <iterator>
#include <type_traits>
 
namespace boost { namespace gil {
 
// forward declarations
template <typename T, typename L> struct pixel;
template <typename BitField,typename ChannelRefs,typename Layout> struct packed_pixel;
template <typename T, typename C> struct planar_pixel_reference;
template <typename IC, typename C> struct planar_pixel_iterator;
template <typename I> class memory_based_step_iterator;
template <typename I> class memory_based_2d_locator;
template <typename L> class image_view;
template <typename Pixel, bool IsPlanar = false, typename Alloc=std::allocator<unsigned char> > class image;
template <typename T> struct channel_type;
template <typename T> struct color_space_type;
template <typename T> struct channel_mapping_type;
template <typename It> struct is_iterator_adaptor;
template <typename It> struct iterator_adaptor_get_base;
template <typename BitField, typename ChannelBitSizes, typename Layout, bool IsMutable> struct bit_aligned_pixel_reference;
 
 
 
 
template <typename PixelRef>
struct pixel_reference_is_basic : public std::false_type {};
 
template <typename T, typename L>
struct pixel_reference_is_basic<pixel<T, L>&> : std::true_type {};
 
template <typename T, typename L>
struct pixel_reference_is_basic<const pixel<T, L>&> : std::true_type {};
 
template <typename TR, typename CS>
struct pixel_reference_is_basic<planar_pixel_reference<TR, CS>> : std::true_type {};
 
template <typename TR, typename CS>
struct pixel_reference_is_basic<const planar_pixel_reference<TR, CS>> : std::true_type {};
 
template <typename Iterator>
struct iterator_is_basic : std::false_type {};
 
template <typename T, typename L>
struct iterator_is_basic<pixel<T, L>*> : std::true_type {};
 
template <typename T, typename L>
struct iterator_is_basic<pixel<T, L> const*> : std::true_type {};
 
template <typename T, typename CS>
struct iterator_is_basic<planar_pixel_iterator<T*, CS>> : std::true_type {};
 
template <typename T, typename CS>
struct iterator_is_basic<planar_pixel_iterator<T const*, CS>> : std::true_type {};
 
template <typename T, typename L>
struct iterator_is_basic<memory_based_step_iterator<pixel<T, L>*>> : std::true_type {};
 
template <typename T, typename L>
struct iterator_is_basic<memory_based_step_iterator<pixel<T, L> const*>> : std::true_type {};
 
template <typename T, typename CS>
struct iterator_is_basic<memory_based_step_iterator<planar_pixel_iterator<T*, CS>>>
    : std::true_type
{};
 
template <typename T, typename CS>
struct iterator_is_basic<memory_based_step_iterator<planar_pixel_iterator<T const*, CS>>>
    : std::true_type
{};
 
 
template <typename Loc>
struct locator_is_basic : std::false_type {};
 
template <typename Iterator>
struct locator_is_basic
    <
        memory_based_2d_locator<memory_based_step_iterator<Iterator>>
    > : iterator_is_basic<Iterator>
{};
 
template <typename View>
struct view_is_basic : std::false_type {};
 
template <typename Loc>
struct view_is_basic<image_view<Loc>> : locator_is_basic<Loc> {};
 
template <typename Img>
struct image_is_basic : std::false_type {};
 
template <typename Pixel, bool IsPlanar, typename Alloc>
struct image_is_basic<image<Pixel, IsPlanar, Alloc>> : std::true_type {};
 
 
 
template <typename I>
struct iterator_is_step;
 
namespace detail {
 
template <typename It, bool IsBase, bool EqualsStepType>
struct iterator_is_step_impl;
 
// iterator that has the same type as its dynamic_x_step_type must be a step iterator
template <typename It, bool IsBase>
struct iterator_is_step_impl<It, IsBase, true> : std::true_type {};
 
// base iterator can never be a step iterator
template <typename It>
struct iterator_is_step_impl<It, true, false> : std::false_type {};
 
// for an iterator adaptor, see if its base is step
template <typename It>
struct iterator_is_step_impl<It, false, false>
    : public iterator_is_step<typename iterator_adaptor_get_base<It>::type> {};
 
} // namespace detail
 
template <typename I>
struct iterator_is_step
    : detail::iterator_is_step_impl
    <
        I,
        !is_iterator_adaptor<I>::value,
        std::is_same<I, typename dynamic_x_step_type<I>::type
    >::value
>
{};
 
template <typename L> struct locator_is_step_in_x : public iterator_is_step<typename L::x_iterator> {};
 
template <typename L> struct locator_is_step_in_y : public iterator_is_step<typename L::y_iterator> {};
 
template <typename V> struct view_is_step_in_x : public locator_is_step_in_x<typename V::xy_locator> {};
 
template <typename V> struct view_is_step_in_y : public locator_is_step_in_y<typename V::xy_locator> {};
 
template <typename PixelReference>
struct pixel_reference_is_proxy
    : mp11::mp_not
    <
        std::is_same
        <
            typename detail::remove_const_and_reference<PixelReference>::type,
            typename detail::remove_const_and_reference<PixelReference>::type::value_type
        >
    >
{};
 
template <typename Pixel>
struct pixel_is_reference
    : mp11::mp_or<is_reference<Pixel>, pixel_reference_is_proxy<Pixel>> {};
 
 
template <typename R>
struct pixel_reference_is_mutable
    : std::integral_constant<bool, std::remove_reference<R>::type::is_mutable>
{};
 
template <typename R>
struct pixel_reference_is_mutable<R const&>
    : mp11::mp_and<pixel_reference_is_proxy<R>, pixel_reference_is_mutable<R>>
{};
 
template <typename L> struct locator_is_mutable : public iterator_is_mutable<typename L::x_iterator> {};
template <typename V> struct view_is_mutable : public iterator_is_mutable<typename V::x_iterator> {};
 
 
 
 
 
 
template <typename T, typename L, bool IsPlanar=false, bool IsMutable=true> struct pixel_reference_type{};
template <typename T, typename L> struct pixel_reference_type<T,L,false,true > { using type = pixel<T,L>&; };
template <typename T, typename L> struct pixel_reference_type<T,L,false,false> { using type = pixel<T,L> const&; };
template <typename T, typename L> struct pixel_reference_type<T,L,true,true> { using type = planar_pixel_reference<typename channel_traits<T>::reference,typename color_space_type<L>::type> const; };       // TODO: Assert M=identity
template <typename T, typename L> struct pixel_reference_type<T,L,true,false> { using type = planar_pixel_reference<typename channel_traits<T>::const_reference,typename color_space_type<L>::type> const; };// TODO: Assert M=identity
 
template <typename Pixel, bool IsPlanar=false, bool IsStep=false, bool IsMutable=true> struct iterator_type_from_pixel{};
template <typename Pixel> struct iterator_type_from_pixel<Pixel,false,false,true > { using type = Pixel *; };
template <typename Pixel> struct iterator_type_from_pixel<Pixel,false,false,false> { using type = const Pixel *; };
template <typename Pixel> struct iterator_type_from_pixel<Pixel,true,false,true> {
    using type = planar_pixel_iterator<typename channel_traits<typename channel_type<Pixel>::type>::pointer,typename color_space_type<Pixel>::type>;
};
template <typename Pixel> struct iterator_type_from_pixel<Pixel,true,false,false> {
    using type = planar_pixel_iterator<typename channel_traits<typename channel_type<Pixel>::type>::const_pointer,typename color_space_type<Pixel>::type>;
};
template <typename Pixel, bool IsPlanar, bool IsMutable> struct iterator_type_from_pixel<Pixel,IsPlanar,true,IsMutable> {
    using type = memory_based_step_iterator<typename iterator_type_from_pixel<Pixel,IsPlanar,false,IsMutable>::type>;
};
 
template <typename T, typename L, bool IsPlanar=false, bool IsStep=false, bool IsMutable=true> struct iterator_type{};
template <typename T, typename L> struct iterator_type<T,L,false,false,true > { using type = pixel<T,L>*; };
template <typename T, typename L> struct iterator_type<T,L,false,false,false> { using type = pixel<T,L> const*; };
template <typename T, typename L> struct iterator_type<T,L,true,false,true> { using type = planar_pixel_iterator<T*,typename L::color_space_t>; };               // TODO: Assert M=identity
template <typename T, typename L> struct iterator_type<T,L,true,false,false> { using type = planar_pixel_iterator<const T*,typename L::color_space_t>; };        // TODO: Assert M=identity
template <typename T, typename L, bool IsPlanar, bool IsMutable> struct iterator_type<T,L,IsPlanar,true,IsMutable> {
    using type = memory_based_step_iterator<typename iterator_type<T,L,IsPlanar,false,IsMutable>::type>;
};
 
template <typename XIterator>
struct type_from_x_iterator
{
    using step_iterator_t = memory_based_step_iterator<XIterator>;
    using xy_locator_t = memory_based_2d_locator<step_iterator_t>;
    using view_t = image_view<xy_locator_t>;
};
 
namespace detail {
 
template <typename BitField, typename FirstBit, typename NumBits>
struct packed_channel_reference_type
{
    using type = packed_channel_reference
        <
            BitField, FirstBit::value, NumBits::value, true
        > const;
};
 
template <typename BitField, typename ChannelBitSizes>
class packed_channel_references_vector_type
{
    template <typename FirstBit, typename NumBits>
    using reference_type = typename packed_channel_reference_type<BitField, FirstBit, NumBits>::type;
 
    // If ChannelBitSizesVector is mp11::mp_list_c<int,7,7,2>
    // Then first_bits_vector will be mp11::mp_list_c<int,0,7,14,16>
    using first_bit_list = mp11::mp_fold_q
        <
            ChannelBitSizes,
            mp11::mp_list<std::integral_constant<int, 0>>,
            mp11::mp_bind
            <
                mp11::mp_push_back,
                mp11::_1,
                mp11::mp_bind
                <
                    mp11::mp_plus,
                    mp11::mp_bind<mp_back, mp11::_1>,
                    mp11::_2
                >
            >
        >;
 
    static_assert(mp11::mp_at_c<first_bit_list, 0>::value == 0, "packed channel first bit must be 0");
 
public:
    using type = mp11::mp_transform
        <
            reference_type,
            mp_pop_back<first_bit_list>,
            ChannelBitSizes
        >;
};
 
} // namespace detail
 
template <typename BitField, typename ChannelBitSizes, typename Layout>
struct packed_pixel_type
{
    using type = packed_pixel
        <
            BitField,
            typename detail::packed_channel_references_vector_type
            <
                BitField,
                ChannelBitSizes
            >::type,
        Layout>;
};
 
 
template <typename BitField, typename ChannelBitSizes, typename Layout, typename Alloc=std::allocator<unsigned char>>
struct packed_image_type
{
    using type = image<typename packed_pixel_type<BitField,ChannelBitSizes,Layout>::type,false,Alloc>;
};
 
template <typename BitField, unsigned Size1, typename Layout, typename Alloc = std::allocator<unsigned char>>
struct packed_image1_type
    : packed_image_type<BitField, mp11::mp_list_c<unsigned, Size1>, Layout, Alloc>
{};
 
template <typename BitField, unsigned Size1, unsigned Size2, typename Layout, typename Alloc = std::allocator<unsigned char>>
struct packed_image2_type
    : packed_image_type<BitField, mp11::mp_list_c<unsigned, Size1, Size2>, Layout, Alloc>
{};
 
template <typename BitField, unsigned Size1, unsigned Size2, unsigned Size3, typename Layout, typename Alloc = std::allocator<unsigned char>>
struct packed_image3_type
    : packed_image_type<BitField, mp11::mp_list_c<unsigned, Size1, Size2, Size3>, Layout, Alloc>
{};
 
template <typename BitField, unsigned Size1, unsigned Size2, unsigned Size3, unsigned Size4, typename Layout, typename Alloc = std::allocator<unsigned char>>
struct packed_image4_type
    : packed_image_type<BitField, mp11::mp_list_c<unsigned, Size1, Size2, Size3, Size4>, Layout, Alloc>
{};
 
template <typename BitField, unsigned Size1, unsigned Size2, unsigned Size3, unsigned Size4, unsigned Size5, typename Layout, typename Alloc = std::allocator<unsigned char>>
struct packed_image5_type
    : packed_image_type<BitField, mp11::mp_list_c<unsigned, Size1, Size2, Size3, Size4, Size5>, Layout, Alloc> {};
 
 
template
<
    typename ChannelBitSizes,
    typename Layout,
    typename Alloc = std::allocator<unsigned char>
>
struct bit_aligned_image_type
{
private:
 
    static constexpr int bit_size =
        mp11::mp_fold
        <
            ChannelBitSizes,
            std::integral_constant<int, 0>,
            mp11::mp_plus
        >::value;
 
    using bitfield_t = typename detail::min_fast_uint<bit_size + 7>::type;
    using bit_alignedref_t = bit_aligned_pixel_reference<bitfield_t, ChannelBitSizes, Layout, true> const;
 
public:
    using type = image<bit_alignedref_t,false,Alloc>;
};
 
template <unsigned Size1, typename Layout, typename Alloc = std::allocator<unsigned char>>
struct bit_aligned_image1_type : bit_aligned_image_type<mp11::mp_list_c<unsigned, Size1>, Layout, Alloc> {};
 
template <unsigned Size1, unsigned Size2, typename Layout, typename Alloc = std::allocator<unsigned char>>
struct bit_aligned_image2_type : bit_aligned_image_type<mp11::mp_list_c<unsigned, Size1, Size2>, Layout, Alloc> {};
 
template <unsigned Size1, unsigned Size2, unsigned Size3, typename Layout, typename Alloc = std::allocator<unsigned char>>
struct bit_aligned_image3_type : bit_aligned_image_type<mp11::mp_list_c<unsigned, Size1, Size2, Size3>, Layout, Alloc> {};
 
template <unsigned Size1, unsigned Size2, unsigned Size3, unsigned Size4, typename Layout, typename Alloc = std::allocator<unsigned char>>
struct bit_aligned_image4_type : bit_aligned_image_type<mp11::mp_list_c<unsigned, Size1, Size2, Size3, Size4>, Layout, Alloc> {};
 
template <unsigned Size1, unsigned Size2, unsigned Size3, unsigned Size4, unsigned Size5, typename Layout, typename Alloc = std::allocator<unsigned char>>
struct bit_aligned_image5_type : bit_aligned_image_type<mp11::mp_list_c<unsigned, Size1, Size2, Size3, Size4, Size5>, Layout, Alloc> {};
 
 
template <typename Channel, typename Layout>
struct pixel_value_type
{
    // by default use gil::pixel. Specializations are provided for
    using type = pixel<Channel, Layout>;
};
 
// Specializations for packed channels
template <typename BitField, int NumBits, bool IsMutable, typename Layout>
struct pixel_value_type<packed_dynamic_channel_reference<BitField, NumBits, IsMutable>, Layout>
    : packed_pixel_type<BitField, mp11::mp_list_c<unsigned, NumBits>, Layout>
{};
 
template <typename BitField, int NumBits, bool IsMutable, typename Layout>
struct pixel_value_type<packed_dynamic_channel_reference<BitField, NumBits, IsMutable> const, Layout>
    : packed_pixel_type<BitField, mp11::mp_list_c<unsigned, NumBits>, Layout>
{};
 
template <typename BitField, int FirstBit, int NumBits, bool IsMutable, typename Layout>
struct pixel_value_type<packed_channel_reference<BitField, FirstBit, NumBits, IsMutable>, Layout>
    : packed_pixel_type<BitField, mp11::mp_list_c<unsigned, NumBits>, Layout>
{};
 
template <typename BitField, int FirstBit, int NumBits, bool IsMutable, typename Layout>
struct pixel_value_type<packed_channel_reference<BitField, FirstBit, NumBits, IsMutable> const, Layout>
    : packed_pixel_type<BitField, mp11::mp_list_c<unsigned, NumBits>, Layout>
{};
 
template <int NumBits, typename Layout>
struct pixel_value_type<packed_channel_value<NumBits>, Layout>
    : packed_pixel_type<typename detail::min_fast_uint<NumBits>::type, mp11::mp_list_c<unsigned, NumBits>, Layout>
{};
 
template <typename T, typename L, bool IsPlanar = false, bool IsStepX = false, bool IsMutable = true>
struct locator_type
{
    using type = typename type_from_x_iterator
        <
            typename iterator_type<T, L, IsPlanar, IsStepX, IsMutable>::type
        >::xy_locator_type;
};
 
template <typename T, typename L, bool IsPlanar = false, bool IsStepX = false, bool IsMutable = true>
struct view_type
{
    using type = typename type_from_x_iterator
        <
            typename iterator_type<T, L, IsPlanar, IsStepX, IsMutable>::type
        >::view_t;
};
 
template <typename T, typename L, bool IsPlanar = false, typename Alloc = std::allocator<unsigned char>>
struct image_type
{
    using type = image<pixel<T, L>, IsPlanar, Alloc>;
};
 
template <typename Pixel, bool IsPlanar=false, bool IsStepX=false, bool IsMutable=true>
struct view_type_from_pixel {
    using type = typename type_from_x_iterator<typename iterator_type_from_pixel<Pixel,IsPlanar,IsStepX,IsMutable>::type>::view_t;
};
 
 
template
<
        typename Ref,
        typename T = use_default,
        typename L = use_default,
        typename IsPlanar = use_default,
        typename IsMutable = use_default>
class derived_pixel_reference_type
{
    using pixel_t = typename std::remove_reference<Ref>::type;
 
    using channel_t = typename mp11::mp_if
        <
            std::is_same<T, use_default>,
            typename channel_type<pixel_t>::type,
            T
        >::type;
 
    using layout_t = typename  mp11::mp_if
        <
            std::is_same<L, use_default>,
            layout
            <
                typename color_space_type<pixel_t>::type,
                typename channel_mapping_type<pixel_t>::type
            >,
            L
        >::type;
 
    static bool const mut = mp11::mp_if
        <
            std::is_same<IsMutable, use_default>,
            pixel_reference_is_mutable<Ref>,
            IsMutable
        >::value;
 
    static bool const planar = mp11::mp_if
        <
            std::is_same<IsPlanar, use_default>,
            is_planar<pixel_t>,
            IsPlanar
        >::value;
 
public:
    using type = typename pixel_reference_type<channel_t, layout_t, planar, mut>::type;
};
 
template
<
    typename Iterator,
    typename T = use_default,
    typename L = use_default,
    typename IsPlanar = use_default,
    typename IsStep = use_default,
    typename IsMutable = use_default
>
class derived_iterator_type
{
    using channel_t = typename mp11::mp_if
        <
            std::is_same<T, use_default>,
            typename channel_type<Iterator>::type,
            T
        >::type;
 
    using layout_t = typename mp11::mp_if
        <
            std::is_same<L, use_default>,
            layout
            <
                typename color_space_type<Iterator>::type,
                typename channel_mapping_type<Iterator>::type
            >,
            L
        >::type;
 
    static const bool mut = mp11::mp_if
        <
            std::is_same<IsMutable, use_default>,
            iterator_is_mutable<Iterator>,
            IsMutable
        >::value;
 
    static bool const planar = mp11::mp_if
        <
            std::is_same<IsPlanar, use_default>,
            is_planar<Iterator>,
            IsPlanar
        >::value;
 
    static bool const step = mp11::mp_if
        <
            std::is_same<IsStep, use_default>,
            iterator_is_step<Iterator>,
            IsStep
        >::type::value;
 
public:
    using type = typename iterator_type<channel_t, layout_t, planar, step, mut>::type;
};
 
template <typename View, typename T = use_default, typename L = use_default, typename IsPlanar = use_default, typename StepX = use_default, typename IsMutable = use_default>
class derived_view_type
{
    using channel_t = typename mp11::mp_if
        <
            std::is_same<T, use_default>,
            typename channel_type<View>::type,
            T
        >;
 
    using layout_t = typename mp11::mp_if
        <
            std::is_same<L, use_default>,
            layout
            <
                typename color_space_type<View>::type,
                typename channel_mapping_type<View>::type
            >,
            L
        >;
 
    static bool const mut = mp11::mp_if
        <
            std::is_same<IsMutable, use_default>,
            view_is_mutable<View>,
            IsMutable
        >::value;
 
    static bool const planar = mp11::mp_if
        <
            std::is_same<IsPlanar, use_default>,
            is_planar<View>,
            IsPlanar
        >::value;
 
    static bool const step = mp11::mp_if
        <
            std::is_same<StepX, use_default>,
            view_is_step_in_x<View>,
            StepX
        >::value;
 
public:
    using type = typename view_type<channel_t, layout_t, planar, step, mut>::type;
};
 
template <typename Image, typename T = use_default, typename L = use_default, typename IsPlanar = use_default>
class derived_image_type
{
    using channel_t = typename mp11::mp_if
        <
            std::is_same<T, use_default>,
            typename channel_type<Image>::type,
            T
        >::type;
 
    using layout_t = typename mp11::mp_if
        <
            std::is_same<L, use_default>,
            layout
            <
                typename color_space_type<Image>::type,
                typename channel_mapping_type<Image>::type>,
                L
            >::type;
 
    static bool const planar = mp11::mp_if
        <
            std::is_same<IsPlanar, use_default>,
            is_planar<Image>,
            IsPlanar
        >::value;
 
public:
    using type = typename image_type<channel_t, layout_t, planar>::type;
};
 
}}  // namespace boost::gil
 
#endif