Edit: /usr/include/boost/gil/pixel.hpp (9866B)
//
// Copyright 2005-2007 Adobe Systems Incorporated
// Copyright 2019 Mateusz Loskot
//
// 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_PIXEL_HPP
#define BOOST_GIL_PIXEL_HPP
#include
#include
#include
#include
#include
#include
#include
#include
#include
namespace boost { namespace gil {
// Forward-declare gray_t
struct gray_color_t;
using gray_t = mp11::mp_list;
template struct color_space_type;
template struct channel_mapping_type;
template struct channel_type;
template struct is_planar;
template
struct color_space_type : color_space_type {};
template
struct channel_mapping_type : channel_mapping_type {};
template
struct channel_type : channel_type {};
template
struct is_planar : std::false_type {};
template
struct is_planar : is_planar {};
template struct is_pixel : std::false_type {};
template struct is_pixel : is_pixel {};
/// \ingroup PixelBasedAlgorithm
/// \brief Returns the number of channels of a pixel-based GIL construct
template
struct num_channels : mp11::mp_size::type>::type {};
/**
\addtogroup PixelBasedAlgorithm
Example:
\code
static_assert(num_channels::value == 3, "");
static_assert(num_channels::value == 4, "");
static_assert(is_planar::value));
static_assert(std::is_same::type, rgb_t>::value, "");
static_assert(std::is_same::type,
channel_mapping_type::type>::value, "");
static_assert(std::is_same::type, uint8_t>::value, "");
\endcode
*/
/// \defgroup ColorBaseModelPixel pixel
/// \ingroup ColorBaseModel
/// \brief A homogeneous color base whose element is a channel value. Models HomogeneousColorBaseValueConcept
/// \defgroup PixelModelPixel pixel
/// \ingroup PixelModel
/// \brief A homogeneous pixel value. Models HomogeneousPixelValueConcept
/// \ingroup PixelModelPixel ColorBaseModelPixel PixelBasedModel
/// \brief Represents a pixel value (a container of channels). Models: HomogeneousColorBaseValueConcept, PixelValueConcept, HomogeneousPixelBasedConcept
///
/// A pixel is a set of channels defining the color at a given point in an image. Conceptually, a pixel is little more than a color base whose elements
/// model \p ChannelConcept. The class \p pixel defines a simple, homogeneous pixel value. It is used to store
/// the value of a color. The built-in C++ references to \p pixel, \p pixel& and \p const \p pixel& are used to represent a reference to a pixel
/// inside an interleaved image view (a view in which all channels are together in memory). Similarly, built-in pointer types \p pixel* and \p const \p pixel*
/// are used as the standard iterator over a row of interleaved homogeneous pixels.
///
/// Since \p pixel inherits the properties of color base, assigning, equality comparison and copy-construcion are allowed between compatible pixels.
/// This means that an 8-bit RGB pixel may be assigned to an 8-bit BGR pixel, or to an 8-bit planar reference. The channels are properly paired semantically.
///
/// The single-channel (grayscale) instantiation of the class pixel, (i.e. \p pixel) is also convertible to/from a channel value.
/// This allows grayscale pixels to be used in simpler expressions like *gray_pix1 = *gray_pix2 instead of more complicated at_c<0>(gray_pix1) = at_c<0>(gray_pix2)
/// or get_color(gray_pix1) = get_color(gray_pix2)
///
/// \tparam ChannelValue TODO
/// \tparam Layout mp11::make_integer_sequence
template
struct pixel :
detail::homogeneous_color_base
<
ChannelValue,
Layout,
mp11::mp_size::value
>
{
private:
using channel_t = ChannelValue;
using parent_t = detail::homogeneous_color_base
<
ChannelValue,
Layout,
mp11::mp_size::value
>;
public:
using value_type = pixel;
using reference = value_type&;
using const_reference = value_type const&;
static constexpr bool is_mutable = channel_traits::is_mutable;
pixel() = default;
explicit pixel(channel_t v) : parent_t(v) {} // sets all channels to v
pixel(channel_t v0, channel_t v1) : parent_t(v0, v1) {}
pixel(channel_t v0, channel_t v1, channel_t v2) : parent_t(v0, v1, v2) {}
pixel(channel_t v0, channel_t v1, channel_t v2, channel_t v3)
: parent_t(v0, v1, v2, v3)
{}
pixel(channel_t v0, channel_t v1, channel_t v2, channel_t v3, channel_t v4)
: parent_t(v0, v1, v2, v3, v4)
{}
pixel(channel_t v0, channel_t v1, channel_t v2, channel_t v3, channel_t v4, channel_t v5)
: parent_t(v0, v1, v2, v3, v4, v5)
{}
pixel(const pixel& p) : parent_t(p) {}
pixel& operator=(pixel const& p)
{
static_copy(p,*this);
return *this;
}
// Construct from another compatible pixel type
template
pixel(Pixel const& p,
typename std::enable_if::value>::type* /*dummy*/ = nullptr)
: parent_t(p)
{
check_compatible();
}
template
pixel& operator=(Pixel const& p)
{
assign(p, is_pixel());
return *this;
}
template
bool operator==(Pixel const& p) const { return equal(p, is_pixel()); }
template
bool operator!=(Pixel const& p) const { return !(*this == p); }
// homogeneous pixels have operator[]
auto operator[](std::size_t index)
-> typename channel_traits::reference
{
return dynamic_at_c(*this, index);
}
auto operator[](std::size_t index) const
-> typename channel_traits::const_reference
{
return dynamic_at_c(*this, index);
}
private:
template
void assign(Pixel const& p, std::true_type)
{
check_compatible();
static_copy(p, *this);
}
template
bool equal(Pixel const& p, std::true_type) const
{
check_compatible();
return static_equal(*this, p);
}
template
void check_compatible() const
{
gil_function_requires>();
}
// Support for assignment/equality comparison of a channel with a grayscale pixel
private:
static void check_gray()
{
static_assert(std::is_same::value, "");
}
template
void assign(Channel const& channel, std::false_type)
{
check_gray();
gil::at_c<0>(*this) = channel;
}
template
bool equal (Channel const& channel, std::false_type) const
{
check_gray();
return gil::at_c<0>(*this) == channel;
}
public:
pixel& operator= (channel_t channel)
{
check_gray();
gil::at_c<0>(*this) = channel;
return *this;
}
bool operator==(channel_t channel) const
{
check_gray();
return gil::at_c<0>(*this) == channel;
}
};
/////////////////////////////
// ColorBasedConcept
/////////////////////////////
template
struct kth_element_type, K>
{
using type = ChannelValue;
};
template
struct kth_element_reference_type, K>
{
using type = typename channel_traits::reference;
};
template
struct kth_element_reference_type, K>
{
using type = typename channel_traits::const_reference;
};
template
struct kth_element_const_reference_type, K>
{
using type = typename channel_traits::const_reference;
};
/////////////////////////////
// PixelConcept
/////////////////////////////
template
struct is_pixel> : std::true_type {};
/////////////////////////////
// HomogeneousPixelBasedConcept
/////////////////////////////
template
struct color_space_type>
{
using type = typename Layout::color_space_t;
};
template
struct channel_mapping_type>
{
using type = typename Layout::channel_mapping_t;
};
template
struct is_planar> : std::false_type {};
template
struct channel_type>
{
using type = ChannelValue;
};
}} // namespace boost::gil
#endif