8 #ifndef BOOST_GIL_PACKED_PIXEL_HPP     9 #define BOOST_GIL_PACKED_PIXEL_HPP    11 #include <boost/gil/pixel.hpp>    12 #include <boost/gil/detail/mp11.hpp>    15 #include <type_traits>    17 namespace boost { 
namespace gil {
    48 template <
typename BitField, 
typename ChannelRefs, 
typename Layout>
    51     BitField _bitfield{0}; 
    53     using layout_t = Layout;
    54     using value_type = packed_pixel<BitField, ChannelRefs, Layout>;
    55     using reference = value_type&;
    56     using const_reference = value_type 
const&;
    58     static constexpr 
bool is_mutable =
    59         channel_traits<mp11::mp_front<ChannelRefs>>::is_mutable;
    61     packed_pixel() = 
default;
    62     explicit packed_pixel(
const BitField& bitfield) : _bitfield(bitfield) {}
    65     packed_pixel(
const packed_pixel& p) : _bitfield(p._bitfield) {}
    67     template <
typename Pixel>
    68     packed_pixel(Pixel 
const& p,
    69         typename std::enable_if<is_pixel<Pixel>::value>::type*  = 
nullptr)
    71         check_compatible<Pixel>();
    72         static_copy(p, *
this);
    75     packed_pixel(
int chan0, 
int chan1)
    78         static_assert(num_channels<packed_pixel>::value == 2, 
"");
    79         gil::at_c<0>(*
this) = chan0; gil::at_c<1>(*
this) = chan1;
    82     packed_pixel(
int chan0, 
int chan1, 
int chan2)
    85         static_assert(num_channels<packed_pixel>::value == 3, 
"");
    86         gil::at_c<0>(*
this) = chan0;
    87         gil::at_c<1>(*
this) = chan1;
    88         gil::at_c<2>(*
this) = chan2;
    91     packed_pixel(
int chan0, 
int chan1, 
int chan2, 
int chan3)
    94         static_assert(num_channels<packed_pixel>::value == 4, 
"");
    95         gil::at_c<0>(*
this) = chan0;
    96         gil::at_c<1>(*
this) = chan1;
    97         gil::at_c<2>(*
this) = chan2;
    98         gil::at_c<3>(*
this) = chan3;
   101     packed_pixel(
int chan0, 
int chan1, 
int chan2, 
int chan3, 
int chan4)
   104         static_assert(num_channels<packed_pixel>::value == 5, 
"");
   105         gil::at_c<0>(*
this) = chan0;
   106         gil::at_c<1>(*
this) = chan1;
   107         gil::at_c<2>(*
this) = chan2;
   108         gil::at_c<3>(*
this) = chan3;
   109         gil::at_c<4>(*
this) = chan4;
   112     auto operator=(packed_pixel 
const& p) -> packed_pixel&
   114         _bitfield = p._bitfield;
   118     template <
typename Pixel>
   119     auto operator=(Pixel 
const& p) -> packed_pixel&
   121         assign(p, is_pixel<Pixel>());
   125     template <
typename Pixel>
   126     bool operator==(Pixel 
const& p)
 const   128         return equal(p, is_pixel<Pixel>());
   131     template <
typename Pixel>
   132     bool operator!=(Pixel 
const& p)
 const { 
return !(*
this==p); }
   135     template <
typename Pixel>
   136     static void check_compatible()
   138         gil_function_requires<PixelsCompatibleConcept<Pixel, packed_pixel>>();
   141     template <
typename Pixel>
   142     void assign(Pixel 
const& p, std::true_type)
   144         check_compatible<Pixel>();
   145         static_copy(p, *
this);
   148     template <
typename Pixel>
   149     bool  equal(Pixel 
const& p, std::true_type)
 const   151         check_compatible<Pixel>();
   152         return static_equal(*
this, p);
   156     static void check_gray()
   158         static_assert(std::is_same<typename Layout::color_space_t, gray_t>::value, 
"");
   161     template <
typename Channel>
   162     void assign(Channel 
const& channel, std::false_type)
   165         gil::at_c<0>(*
this) = channel;
   168     template <
typename Channel>
   169     bool equal (Channel 
const& channel, std::false_type)
 const   172         return gil::at_c<0>(*
this) == channel;
   176     auto operator=(
int channel) -> packed_pixel&
   179         gil::at_c<0>(*
this) = channel;
   183     bool operator==(
int channel)
 const   186         return gil::at_c<0>(*
this) == channel;
   194 template <
typename BitField, 
typename ChannelRefs, 
typename Layout, 
int K>
   195 struct kth_element_type<packed_pixel<BitField, ChannelRefs, Layout>, K>
   197     using type = 
typename channel_traits<mp11::mp_at_c<ChannelRefs, K>>::value_type;
   200 template <
typename BitField, 
typename ChannelRefs, 
typename Layout, 
int K>
   201 struct kth_element_reference_type<packed_pixel<BitField, ChannelRefs, Layout>, K>
   203     using type = 
typename channel_traits<mp11::mp_at_c<ChannelRefs, K>>::reference;
   206 template <
typename BitField, 
typename ChannelRefs, 
typename Layout, 
int K>
   207 struct kth_element_const_reference_type<packed_pixel<BitField, ChannelRefs, Layout>, K>
   209     using type = 
typename channel_traits<mp11::mp_at_c<ChannelRefs, K>>::const_reference;
   212 template <
int K, 
typename P, 
typename C, 
typename L>
   214 auto at_c(packed_pixel<P, C, L>& p)
   215     -> 
typename kth_element_reference_type<packed_pixel<P, C, L>, K>::type
   217     return typename kth_element_reference_type
   219             packed_pixel<P, C, L>,
   221         >::type{&p._bitfield};
   224 template <
int K, 
typename P, 
typename C, 
typename L>
   226 auto at_c(
const packed_pixel<P, C, L>& p)
   227     -> 
typename kth_element_const_reference_type<packed_pixel<P, C, L>, K>::type
   229     return typename kth_element_const_reference_type
   231             packed_pixel<P, C, L>,
   232         K>::type{&p._bitfield};
   240 template <
typename BitField, 
typename ChannelRefs, 
typename Layout>
   241 struct is_pixel<packed_pixel<BitField, ChannelRefs, Layout>> : std::true_type {};
   247 template <
typename P, 
typename C, 
typename Layout>
   248 struct color_space_type<packed_pixel<P, C, Layout>>
   250     using type = 
typename Layout::color_space_t;
   253 template <
typename P, 
typename C, 
typename Layout>
   254 struct channel_mapping_type<packed_pixel<P, C, Layout>>
   256     using type = 
typename Layout::channel_mapping_t;
   259 template <
typename P, 
typename C, 
typename Layout>
   260 struct is_planar<packed_pixel<P, C, Layout>> : std::false_type {};
   271 template <
typename P, 
typename C, 
typename L>
   272 struct iterator_is_mutable<packed_pixel<P, C, L>*>
   273     : std::integral_constant<bool, packed_pixel<P, C, L>::is_mutable>
   276 template <
typename P, 
typename C, 
typename L>
   277 struct iterator_is_mutable<const packed_pixel<P, C, L>*> : std::false_type {};
 auto at_c(detail::homogeneous_color_base< E, L, N > &p) -> typename std::add_lvalue_reference< E >::type
Provides mutable access to the K-th element, in physical order.
Definition: color_base.hpp:597