[ceph.git] / ceph / src / boost / boost / gil / typedefs.hpp

//
// Copyright 2005-2007 Adobe Systems Incorporated
// Copyright 2018 Mateusz Loskot <mateusz@loskot.net>
//
// Use, modification and distribution are subject to 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_TYPEDEFS_HPP
#define BOOST_GIL_TYPEDEFS_HPP

#include <boost/gil/cmyk.hpp>
#include <boost/gil/device_n.hpp>
#include <boost/gil/gray.hpp>
#include <boost/gil/point.hpp>
#include <boost/gil/rgb.hpp>
#include <boost/gil/rgba.hpp>

#include <cstdint>
#include <memory>

// B - bits size/signedness, CM - channel model, CS - colour space, LAYOUT - pixel layout
// Example: B = '8', CM = 'uint8_t', CS = 'bgr,  LAYOUT='bgr_layout_t'
#define BOOST_GIL_DEFINE_BASE_TYPEDEFS_INTERNAL(B, CM, CS, LAYOUT)                             \
    template <typename, typename> struct pixel;                                          \
    template <typename, typename> struct planar_pixel_reference;                         \
    template <typename, typename> struct planar_pixel_iterator;                          \
    template <typename> class memory_based_step_iterator;                                \
    template <typename> class point;                                                    \
    template <typename> class memory_based_2d_locator;                                   \
    template <typename> class image_view;                                                \
    template <typename, bool, typename> class image;                                     \
    using CS##B##_pixel_t     = pixel<CM, LAYOUT>;                                       \
    using CS##B##c_pixel_t    = pixel<CM, LAYOUT> const;                                 \
    using CS##B##_ref_t       = pixel<CM, LAYOUT>&;                                      \
    using CS##B##c_ref_t      = pixel<CM, LAYOUT> const&;                                \
    using CS##B##_ptr_t       = CS##B##_pixel_t*;                                        \
    using CS##B##c_ptr_t      = CS##B##c_pixel_t*;                                       \
    using CS##B##_step_ptr_t  = memory_based_step_iterator<CS##B##_ptr_t>;               \
    using CS##B##c_step_ptr_t = memory_based_step_iterator<CS##B##c_ptr_t>;              \
    using CS##B##_loc_t                                                                  \
        = memory_based_2d_locator<memory_based_step_iterator<CS##B##_ptr_t>>;            \
    using CS##B##c_loc_t                                                                 \
        = memory_based_2d_locator<memory_based_step_iterator<CS##B##c_ptr_t>>;           \
    using CS##B##_step_loc_t                                                             \
        = memory_based_2d_locator<memory_based_step_iterator<CS##B##_step_ptr_t>>;       \
    using CS##B##c_step_loc_t                                                            \
        = memory_based_2d_locator<memory_based_step_iterator<CS##B##c_step_ptr_t>>;      \
    using CS##B##_view_t       = image_view<CS##B##_loc_t>;                              \
    using CS##B##c_view_t      = image_view<CS##B##c_loc_t>;                             \
    using CS##B##_step_view_t  = image_view<CS##B##_step_loc_t>;                         \
    using CS##B##c_step_view_t = image_view<CS##B##c_step_loc_t>;                        \
    using CS##B##_image_t = image<CS##B##_pixel_t, false, std::allocator<unsigned char>>;

// Example: B = '8', CM = 'uint8_t', CS = 'bgr' CS_FULL = 'rgb_t' LAYOUT='bgr_layout_t'
#define BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(B, CM, CS, CS_FULL, LAYOUT)                        \
    BOOST_GIL_DEFINE_BASE_TYPEDEFS_INTERNAL(B, CM, CS, LAYOUT)                                    \
    using CS##B##_planar_ref_t      = planar_pixel_reference<CM&, CS_FULL>;                 \
    using CS##B##c_planar_ref_t     = planar_pixel_reference<CM const&, CS_FULL>;           \
    using CS##B##_planar_ptr_t      = planar_pixel_iterator<CM*, CS_FULL>;                  \
    using CS##B##c_planar_ptr_t     = planar_pixel_iterator<CM const*, CS_FULL>;            \
    using CS##B##_planar_step_ptr_t = memory_based_step_iterator<CS##B##_planar_ptr_t>;     \
    using CS##B##c_planar_step_ptr_t                                                        \
        = memory_based_step_iterator<CS##B##c_planar_ptr_t>;                                \
    using CS##B##_planar_loc_t                                                              \
        = memory_based_2d_locator<memory_based_step_iterator<CS##B##_planar_ptr_t>>;        \
    using CS##B##c_planar_loc_t                                                             \
        = memory_based_2d_locator<memory_based_step_iterator<CS##B##c_planar_ptr_t>>;       \
    using CS##B##_planar_step_loc_t                                                         \
        = memory_based_2d_locator<memory_based_step_iterator<CS##B##_planar_step_ptr_t>>;   \
    using CS##B##c_planar_step_loc_t                                                        \
        = memory_based_2d_locator<memory_based_step_iterator<CS##B##c_planar_step_ptr_t>>;  \
    using CS##B##_planar_view_t       = image_view<CS##B##_planar_loc_t>;                   \
    using CS##B##c_planar_view_t      = image_view<CS##B##c_planar_loc_t>;                  \
    using CS##B##_planar_step_view_t  = image_view<CS##B##_planar_step_loc_t>;              \
    using CS##B##c_planar_step_view_t = image_view<CS##B##c_planar_step_loc_t>;             \
    using CS##B##_planar_image_t                                                            \
        = image<CS##B##_pixel_t, true, std::allocator<unsigned char>>;

#define BOOST_GIL_DEFINE_BASE_TYPEDEFS(B, CM, CS)                                                  \
    BOOST_GIL_DEFINE_BASE_TYPEDEFS_INTERNAL(B, CM, CS, CS##_layout_t)

#define BOOST_GIL_DEFINE_ALL_TYPEDEFS(B, CM, CS)                                                   \
    BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(B, CM, CS, CS##_t, CS##_layout_t)


namespace boost { namespace gil {

// forward declarations
template <typename B, typename Mn, typename Mx> struct scoped_channel_value;
template <typename T> struct float_point_zero;
template <typename T> struct float_point_one;

//////////////////////////////////////////////////////////////////////////////////////////
///  Built-in channel models
//////////////////////////////////////////////////////////////////////////////////////////

/// \ingroup ChannelModel
/// \brief 8-bit unsigned integral channel type (alias from uint8_t). Models ChannelValueConcept
using std::uint8_t;

/// \ingroup ChannelModel
/// \brief 16-bit unsigned integral channel type (alias from uint16_t). Models ChannelValueConcept
using std::uint16_t;

/// \ingroup ChannelModel
/// \brief 32-bit unsigned integral channel type  (alias from uint32_t). Models ChannelValueConcept
using std::uint32_t;

/// \ingroup ChannelModel
/// \brief 8-bit signed integral channel type (alias from int8_t). Models ChannelValueConcept
using std::int8_t;

/// \ingroup ChannelModel
/// \brief 16-bit signed integral channel type (alias from int16_t). Models ChannelValueConcept
using std::int16_t;

/// \ingroup ChannelModel
/// \brief 32-bit signed integral channel type (alias from int32_t). Models ChannelValueConcept
using std::int32_t;

/// \ingroup ChannelModel
/// \brief 32-bit floating point channel type with range [0.0f ... 1.0f]. Models ChannelValueConcept
using float32_t = scoped_channel_value<float, float_point_zero<float>, float_point_one<float>>;

/// \ingroup ChannelModel
/// \brief 64-bit floating point channel type with range [0.0f ... 1.0f]. Models ChannelValueConcept
using float64_t = scoped_channel_value<double, float_point_zero<double>, float_point_one<double>>;

BOOST_GIL_DEFINE_BASE_TYPEDEFS(8, uint8_t, gray)
BOOST_GIL_DEFINE_BASE_TYPEDEFS(8s, int8_t, gray)
BOOST_GIL_DEFINE_BASE_TYPEDEFS(16, uint16_t, gray)
BOOST_GIL_DEFINE_BASE_TYPEDEFS(16s, int16_t, gray)
BOOST_GIL_DEFINE_BASE_TYPEDEFS(32, uint32_t, gray)
BOOST_GIL_DEFINE_BASE_TYPEDEFS(32s, int32_t, gray)
BOOST_GIL_DEFINE_BASE_TYPEDEFS(32f, float32_t, gray)

BOOST_GIL_DEFINE_BASE_TYPEDEFS(8, uint8_t, bgr)
BOOST_GIL_DEFINE_BASE_TYPEDEFS(8s, int8_t, bgr)
BOOST_GIL_DEFINE_BASE_TYPEDEFS(16, uint16_t, bgr)
BOOST_GIL_DEFINE_BASE_TYPEDEFS(16s, int16_t, bgr)
BOOST_GIL_DEFINE_BASE_TYPEDEFS(32, uint32_t, bgr)
BOOST_GIL_DEFINE_BASE_TYPEDEFS(32s, int32_t, bgr)
BOOST_GIL_DEFINE_BASE_TYPEDEFS(32f, float32_t, bgr)

BOOST_GIL_DEFINE_BASE_TYPEDEFS(8, uint8_t, argb)
BOOST_GIL_DEFINE_BASE_TYPEDEFS(8s, int8_t, argb)
BOOST_GIL_DEFINE_BASE_TYPEDEFS(16, uint16_t, argb)
BOOST_GIL_DEFINE_BASE_TYPEDEFS(16s, int16_t, argb)
BOOST_GIL_DEFINE_BASE_TYPEDEFS(32, uint32_t, argb)
BOOST_GIL_DEFINE_BASE_TYPEDEFS(32s, int32_t, argb)
BOOST_GIL_DEFINE_BASE_TYPEDEFS(32f, float32_t, argb)

BOOST_GIL_DEFINE_BASE_TYPEDEFS(8, uint8_t, abgr)
BOOST_GIL_DEFINE_BASE_TYPEDEFS(8s, int8_t, abgr)
BOOST_GIL_DEFINE_BASE_TYPEDEFS(16, uint16_t, abgr)
BOOST_GIL_DEFINE_BASE_TYPEDEFS(16s, int16_t, abgr)
BOOST_GIL_DEFINE_BASE_TYPEDEFS(32, uint32_t, abgr)
BOOST_GIL_DEFINE_BASE_TYPEDEFS(32s, int32_t, abgr)
BOOST_GIL_DEFINE_BASE_TYPEDEFS(32f, float32_t, abgr)

BOOST_GIL_DEFINE_BASE_TYPEDEFS(8, uint8_t, bgra)
BOOST_GIL_DEFINE_BASE_TYPEDEFS(8s, int8_t, bgra)
BOOST_GIL_DEFINE_BASE_TYPEDEFS(16, uint16_t, bgra)
BOOST_GIL_DEFINE_BASE_TYPEDEFS(16s, int16_t, bgra)
BOOST_GIL_DEFINE_BASE_TYPEDEFS(32, uint32_t, bgra)
BOOST_GIL_DEFINE_BASE_TYPEDEFS(32s, int32_t, bgra)
BOOST_GIL_DEFINE_BASE_TYPEDEFS(32f, float32_t, bgra)

BOOST_GIL_DEFINE_ALL_TYPEDEFS(8, uint8_t, rgb)
BOOST_GIL_DEFINE_ALL_TYPEDEFS(8s, int8_t, rgb)
BOOST_GIL_DEFINE_ALL_TYPEDEFS(16, uint16_t, rgb)
BOOST_GIL_DEFINE_ALL_TYPEDEFS(16s, int16_t, rgb)
BOOST_GIL_DEFINE_ALL_TYPEDEFS(32, uint32_t, rgb)
BOOST_GIL_DEFINE_ALL_TYPEDEFS(32s, int32_t, rgb)
BOOST_GIL_DEFINE_ALL_TYPEDEFS(32f, float32_t, rgb)

BOOST_GIL_DEFINE_ALL_TYPEDEFS(8, uint8_t, rgba)
BOOST_GIL_DEFINE_ALL_TYPEDEFS(8s, int8_t, rgba)
BOOST_GIL_DEFINE_ALL_TYPEDEFS(16, uint16_t, rgba)
BOOST_GIL_DEFINE_ALL_TYPEDEFS(16s, int16_t, rgba)
BOOST_GIL_DEFINE_ALL_TYPEDEFS(32, uint32_t, rgba)
BOOST_GIL_DEFINE_ALL_TYPEDEFS(32s, int32_t, rgba)
BOOST_GIL_DEFINE_ALL_TYPEDEFS(32f, float32_t, rgba)

BOOST_GIL_DEFINE_ALL_TYPEDEFS(8, uint8_t, cmyk)
BOOST_GIL_DEFINE_ALL_TYPEDEFS(8s, int8_t, cmyk)
BOOST_GIL_DEFINE_ALL_TYPEDEFS(16, uint16_t, cmyk)
BOOST_GIL_DEFINE_ALL_TYPEDEFS(16s, int16_t, cmyk)
BOOST_GIL_DEFINE_ALL_TYPEDEFS(32, uint32_t, cmyk)
BOOST_GIL_DEFINE_ALL_TYPEDEFS(32s, int32_t, cmyk)
BOOST_GIL_DEFINE_ALL_TYPEDEFS(32f, float32_t, cmyk)

template <int N> struct devicen_t;
template <int N> struct devicen_layout_t;

BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(8, uint8_t, dev2n, devicen_t<2>, devicen_layout_t<2>)
BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(8s, int8_t, dev2n, devicen_t<2>, devicen_layout_t<2>)
BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(16, uint16_t, dev2n, devicen_t<2>, devicen_layout_t<2>)
BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(16s, int16_t, dev2n, devicen_t<2>, devicen_layout_t<2>)
BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(32, uint32_t, dev2n, devicen_t<2>, devicen_layout_t<2>)
BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(32s, int32_t, dev2n, devicen_t<2>, devicen_layout_t<2>)
BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(32f, float32_t, dev2n, devicen_t<2>, devicen_layout_t<2>)

BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(8, uint8_t, dev3n, devicen_t<3>, devicen_layout_t<3>)
BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(8s, int8_t, dev3n, devicen_t<3>, devicen_layout_t<3>)
BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(16, uint16_t, dev3n, devicen_t<3>, devicen_layout_t<3>)
BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(16s, int16_t, dev3n, devicen_t<3>, devicen_layout_t<3>)
BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(32, uint32_t, dev3n, devicen_t<3>, devicen_layout_t<3>)
BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(32s, int32_t, dev3n, devicen_t<3>, devicen_layout_t<3>)
BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(32f, float32_t, dev3n, devicen_t<3>, devicen_layout_t<3>)

BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(8, uint8_t, dev4n, devicen_t<4>, devicen_layout_t<4>)
BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(8s, int8_t, dev4n, devicen_t<4>, devicen_layout_t<4>)
BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(16, uint16_t, dev4n, devicen_t<4>, devicen_layout_t<4>)
BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(16s, int16_t, dev4n, devicen_t<4>, devicen_layout_t<4>)
BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(32, uint32_t, dev4n, devicen_t<4>, devicen_layout_t<4>)
BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(32s, int32_t, dev4n, devicen_t<4>, devicen_layout_t<4>)
BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(32f, float32_t, dev4n, devicen_t<4>, devicen_layout_t<4>)

BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(8, uint8_t, dev5n, devicen_t<5>, devicen_layout_t<5>)
BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(8s, int8_t, dev5n, devicen_t<5>, devicen_layout_t<5>)
BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(16, uint16_t, dev5n, devicen_t<5>, devicen_layout_t<5>)
BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(16s, int16_t, dev5n, devicen_t<5>, devicen_layout_t<5>)
BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(32, uint32_t, dev5n, devicen_t<5>, devicen_layout_t<5>)
BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(32s, int32_t, dev5n, devicen_t<5>, devicen_layout_t<5>)
BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(32f, float32_t, dev5n, devicen_t<5>, devicen_layout_t<5>)

}} // namespace boost::gil

#endif
Commit	Line	Data
92f5a8d4 TL	1	//
	2	// Copyright 2005-2007 Adobe Systems Incorporated
	3	// Copyright 2018 Mateusz Loskot <mateusz@loskot.net>
	4	//
	5	// Use, modification and distribution are subject to the Boost Software License,
	6	// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
	7	// http://www.boost.org/LICENSE_1_0.txt)
	8	//
	9	#ifndef BOOST_GIL_TYPEDEFS_HPP
	10	#define BOOST_GIL_TYPEDEFS_HPP
	11
	12	#include <boost/gil/cmyk.hpp>
	13	#include <boost/gil/device_n.hpp>
	14	#include <boost/gil/gray.hpp>
	15	#include <boost/gil/point.hpp>
	16	#include <boost/gil/rgb.hpp>
	17	#include <boost/gil/rgba.hpp>
	18
	19	#include <cstdint>
7c673cae FG	20	#include <memory>
7c673cae FG	21
92f5a8d4 TL	22	// B - bits size/signedness, CM - channel model, CS - colour space, LAYOUT - pixel layout
92f5a8d4 TL	23	// Example: B = '8', CM = 'uint8_t', CS = 'bgr, LAYOUT='bgr_layout_t'
f67539c2	24	#define BOOST_GIL_DEFINE_BASE_TYPEDEFS_INTERNAL(B, CM, CS, LAYOUT) \
92f5a8d4 TL	25	template <typename, typename> struct pixel; \
	26	template <typename, typename> struct planar_pixel_reference; \
	27	template <typename, typename> struct planar_pixel_iterator; \
	28	template <typename> class memory_based_step_iterator; \
	29	template <typename> class point; \
	30	template <typename> class memory_based_2d_locator; \
	31	template <typename> class image_view; \
	32	template <typename, bool, typename> class image; \
	33	using CS##B##_pixel_t = pixel<CM, LAYOUT>; \
	34	using CS##B##c_pixel_t = pixel<CM, LAYOUT> const; \
	35	using CS##B##_ref_t = pixel<CM, LAYOUT>&; \
	36	using CS##B##c_ref_t = pixel<CM, LAYOUT> const&; \
	37	using CS##B##_ptr_t = CS##B##_pixel_t*; \
	38	using CS##B##c_ptr_t = CS##B##c_pixel_t*; \
	39	using CS##B##_step_ptr_t = memory_based_step_iterator<CS##B##_ptr_t>; \
	40	using CS##B##c_step_ptr_t = memory_based_step_iterator<CS##B##c_ptr_t>; \
	41	using CS##B##_loc_t \
	42	= memory_based_2d_locator<memory_based_step_iterator<CS##B##_ptr_t>>; \
	43	using CS##B##c_loc_t \
	44	= memory_based_2d_locator<memory_based_step_iterator<CS##B##c_ptr_t>>; \
	45	using CS##B##_step_loc_t \
	46	= memory_based_2d_locator<memory_based_step_iterator<CS##B##_step_ptr_t>>; \
	47	using CS##B##c_step_loc_t \
	48	= memory_based_2d_locator<memory_based_step_iterator<CS##B##c_step_ptr_t>>; \
	49	using CS##B##_view_t = image_view<CS##B##_loc_t>; \
	50	using CS##B##c_view_t = image_view<CS##B##c_loc_t>; \
	51	using CS##B##_step_view_t = image_view<CS##B##_step_loc_t>; \
	52	using CS##B##c_step_view_t = image_view<CS##B##c_step_loc_t>; \
	53	using CS##B##_image_t = image<CS##B##_pixel_t, false, std::allocator<unsigned char>>;
	54
	55	// Example: B = '8', CM = 'uint8_t', CS = 'bgr' CS_FULL = 'rgb_t' LAYOUT='bgr_layout_t'
f67539c2 TL	56	#define BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(B, CM, CS, CS_FULL, LAYOUT) \
f67539c2 TL	57	BOOST_GIL_DEFINE_BASE_TYPEDEFS_INTERNAL(B, CM, CS, LAYOUT) \
92f5a8d4 TL	58	using CS##B##_planar_ref_t = planar_pixel_reference<CM&, CS_FULL>; \
	59	using CS##B##c_planar_ref_t = planar_pixel_reference<CM const&, CS_FULL>; \
	60	using CS##B##_planar_ptr_t = planar_pixel_iterator<CM*, CS_FULL>; \
	61	using CS##B##c_planar_ptr_t = planar_pixel_iterator<CM const*, CS_FULL>; \
	62	using CS##B##_planar_step_ptr_t = memory_based_step_iterator<CS##B##_planar_ptr_t>; \
	63	using CS##B##c_planar_step_ptr_t \
	64	= memory_based_step_iterator<CS##B##c_planar_ptr_t>; \
	65	using CS##B##_planar_loc_t \
	66	= memory_based_2d_locator<memory_based_step_iterator<CS##B##_planar_ptr_t>>; \
	67	using CS##B##c_planar_loc_t \
	68	= memory_based_2d_locator<memory_based_step_iterator<CS##B##c_planar_ptr_t>>; \
	69	using CS##B##_planar_step_loc_t \
	70	= memory_based_2d_locator<memory_based_step_iterator<CS##B##_planar_step_ptr_t>>; \
	71	using CS##B##c_planar_step_loc_t \
	72	= memory_based_2d_locator<memory_based_step_iterator<CS##B##c_planar_step_ptr_t>>; \
	73	using CS##B##_planar_view_t = image_view<CS##B##_planar_loc_t>; \
	74	using CS##B##c_planar_view_t = image_view<CS##B##c_planar_loc_t>; \
	75	using CS##B##_planar_step_view_t = image_view<CS##B##_planar_step_loc_t>; \
	76	using CS##B##c_planar_step_view_t = image_view<CS##B##c_planar_step_loc_t>; \
	77	using CS##B##_planar_image_t \
	78	= image<CS##B##_pixel_t, true, std::allocator<unsigned char>>;
	79
f67539c2 TL	80	#define BOOST_GIL_DEFINE_BASE_TYPEDEFS(B, CM, CS) \
f67539c2 TL	81	BOOST_GIL_DEFINE_BASE_TYPEDEFS_INTERNAL(B, CM, CS, CS##_layout_t)
92f5a8d4	82
f67539c2 TL	83	#define BOOST_GIL_DEFINE_ALL_TYPEDEFS(B, CM, CS) \
f67539c2 TL	84	BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(B, CM, CS, CS##_t, CS##_layout_t)
92f5a8d4	85
7c673cae FG	86
	87	namespace boost { namespace gil {
	88
	89	// forward declarations
	90	template <typename B, typename Mn, typename Mx> struct scoped_channel_value;
92f5a8d4 TL	91	template <typename T> struct float_point_zero;
	92	template <typename T> struct float_point_one;
	93
	94	//////////////////////////////////////////////////////////////////////////////////////////
	95	/// Built-in channel models
	96	//////////////////////////////////////////////////////////////////////////////////////////
	97
	98	/// \ingroup ChannelModel
	99	/// \brief 8-bit unsigned integral channel type (alias from uint8_t). Models ChannelValueConcept
	100	using std::uint8_t;
	101
	102	/// \ingroup ChannelModel
	103	/// \brief 16-bit unsigned integral channel type (alias from uint16_t). Models ChannelValueConcept
	104	using std::uint16_t;
	105
	106	/// \ingroup ChannelModel
	107	/// \brief 32-bit unsigned integral channel type (alias from uint32_t). Models ChannelValueConcept
	108	using std::uint32_t;
	109
	110	/// \ingroup ChannelModel
	111	/// \brief 8-bit signed integral channel type (alias from int8_t). Models ChannelValueConcept
	112	using std::int8_t;
	113
	114	/// \ingroup ChannelModel
	115	/// \brief 16-bit signed integral channel type (alias from int16_t). Models ChannelValueConcept
	116	using std::int16_t;
	117
	118	/// \ingroup ChannelModel
	119	/// \brief 32-bit signed integral channel type (alias from int32_t). Models ChannelValueConcept
	120	using std::int32_t;
	121
	122	/// \ingroup ChannelModel
	123	/// \brief 32-bit floating point channel type with range [0.0f ... 1.0f]. Models ChannelValueConcept
	124	using float32_t = scoped_channel_value<float, float_point_zero<float>, float_point_one<float>>;
	125
	126	/// \ingroup ChannelModel
	127	/// \brief 64-bit floating point channel type with range [0.0f ... 1.0f]. Models ChannelValueConcept
	128	using float64_t = scoped_channel_value<double, float_point_zero<double>, float_point_one<double>>;
	129
f67539c2 TL	130	BOOST_GIL_DEFINE_BASE_TYPEDEFS(8, uint8_t, gray)
	131	BOOST_GIL_DEFINE_BASE_TYPEDEFS(8s, int8_t, gray)
	132	BOOST_GIL_DEFINE_BASE_TYPEDEFS(16, uint16_t, gray)
	133	BOOST_GIL_DEFINE_BASE_TYPEDEFS(16s, int16_t, gray)
	134	BOOST_GIL_DEFINE_BASE_TYPEDEFS(32, uint32_t, gray)
	135	BOOST_GIL_DEFINE_BASE_TYPEDEFS(32s, int32_t, gray)
	136	BOOST_GIL_DEFINE_BASE_TYPEDEFS(32f, float32_t, gray)
	137
	138	BOOST_GIL_DEFINE_BASE_TYPEDEFS(8, uint8_t, bgr)
	139	BOOST_GIL_DEFINE_BASE_TYPEDEFS(8s, int8_t, bgr)
	140	BOOST_GIL_DEFINE_BASE_TYPEDEFS(16, uint16_t, bgr)
	141	BOOST_GIL_DEFINE_BASE_TYPEDEFS(16s, int16_t, bgr)
	142	BOOST_GIL_DEFINE_BASE_TYPEDEFS(32, uint32_t, bgr)
	143	BOOST_GIL_DEFINE_BASE_TYPEDEFS(32s, int32_t, bgr)
	144	BOOST_GIL_DEFINE_BASE_TYPEDEFS(32f, float32_t, bgr)
	145
	146	BOOST_GIL_DEFINE_BASE_TYPEDEFS(8, uint8_t, argb)
	147	BOOST_GIL_DEFINE_BASE_TYPEDEFS(8s, int8_t, argb)
	148	BOOST_GIL_DEFINE_BASE_TYPEDEFS(16, uint16_t, argb)
	149	BOOST_GIL_DEFINE_BASE_TYPEDEFS(16s, int16_t, argb)
	150	BOOST_GIL_DEFINE_BASE_TYPEDEFS(32, uint32_t, argb)
	151	BOOST_GIL_DEFINE_BASE_TYPEDEFS(32s, int32_t, argb)
	152	BOOST_GIL_DEFINE_BASE_TYPEDEFS(32f, float32_t, argb)
	153
	154	BOOST_GIL_DEFINE_BASE_TYPEDEFS(8, uint8_t, abgr)
	155	BOOST_GIL_DEFINE_BASE_TYPEDEFS(8s, int8_t, abgr)
	156	BOOST_GIL_DEFINE_BASE_TYPEDEFS(16, uint16_t, abgr)
	157	BOOST_GIL_DEFINE_BASE_TYPEDEFS(16s, int16_t, abgr)
	158	BOOST_GIL_DEFINE_BASE_TYPEDEFS(32, uint32_t, abgr)
	159	BOOST_GIL_DEFINE_BASE_TYPEDEFS(32s, int32_t, abgr)
	160	BOOST_GIL_DEFINE_BASE_TYPEDEFS(32f, float32_t, abgr)
	161
	162	BOOST_GIL_DEFINE_BASE_TYPEDEFS(8, uint8_t, bgra)
	163	BOOST_GIL_DEFINE_BASE_TYPEDEFS(8s, int8_t, bgra)
	164	BOOST_GIL_DEFINE_BASE_TYPEDEFS(16, uint16_t, bgra)
	165	BOOST_GIL_DEFINE_BASE_TYPEDEFS(16s, int16_t, bgra)
	166	BOOST_GIL_DEFINE_BASE_TYPEDEFS(32, uint32_t, bgra)
	167	BOOST_GIL_DEFINE_BASE_TYPEDEFS(32s, int32_t, bgra)
	168	BOOST_GIL_DEFINE_BASE_TYPEDEFS(32f, float32_t, bgra)
	169
	170	BOOST_GIL_DEFINE_ALL_TYPEDEFS(8, uint8_t, rgb)
	171	BOOST_GIL_DEFINE_ALL_TYPEDEFS(8s, int8_t, rgb)
	172	BOOST_GIL_DEFINE_ALL_TYPEDEFS(16, uint16_t, rgb)
	173	BOOST_GIL_DEFINE_ALL_TYPEDEFS(16s, int16_t, rgb)
	174	BOOST_GIL_DEFINE_ALL_TYPEDEFS(32, uint32_t, rgb)
	175	BOOST_GIL_DEFINE_ALL_TYPEDEFS(32s, int32_t, rgb)
	176	BOOST_GIL_DEFINE_ALL_TYPEDEFS(32f, float32_t, rgb)
	177
	178	BOOST_GIL_DEFINE_ALL_TYPEDEFS(8, uint8_t, rgba)
	179	BOOST_GIL_DEFINE_ALL_TYPEDEFS(8s, int8_t, rgba)
	180	BOOST_GIL_DEFINE_ALL_TYPEDEFS(16, uint16_t, rgba)
	181	BOOST_GIL_DEFINE_ALL_TYPEDEFS(16s, int16_t, rgba)
	182	BOOST_GIL_DEFINE_ALL_TYPEDEFS(32, uint32_t, rgba)
	183	BOOST_GIL_DEFINE_ALL_TYPEDEFS(32s, int32_t, rgba)
	184	BOOST_GIL_DEFINE_ALL_TYPEDEFS(32f, float32_t, rgba)
	185
	186	BOOST_GIL_DEFINE_ALL_TYPEDEFS(8, uint8_t, cmyk)
	187	BOOST_GIL_DEFINE_ALL_TYPEDEFS(8s, int8_t, cmyk)
	188	BOOST_GIL_DEFINE_ALL_TYPEDEFS(16, uint16_t, cmyk)
	189	BOOST_GIL_DEFINE_ALL_TYPEDEFS(16s, int16_t, cmyk)
	190	BOOST_GIL_DEFINE_ALL_TYPEDEFS(32, uint32_t, cmyk)
	191	BOOST_GIL_DEFINE_ALL_TYPEDEFS(32s, int32_t, cmyk)
	192	BOOST_GIL_DEFINE_ALL_TYPEDEFS(32f, float32_t, cmyk)
7c673cae FG	193
	194	template <int N> struct devicen_t;
	195	template <int N> struct devicen_layout_t;
92f5a8d4	196
f67539c2 TL	197	BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(8, uint8_t, dev2n, devicen_t<2>, devicen_layout_t<2>)
	198	BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(8s, int8_t, dev2n, devicen_t<2>, devicen_layout_t<2>)
	199	BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(16, uint16_t, dev2n, devicen_t<2>, devicen_layout_t<2>)
	200	BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(16s, int16_t, dev2n, devicen_t<2>, devicen_layout_t<2>)
	201	BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(32, uint32_t, dev2n, devicen_t<2>, devicen_layout_t<2>)
	202	BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(32s, int32_t, dev2n, devicen_t<2>, devicen_layout_t<2>)
	203	BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(32f, float32_t, dev2n, devicen_t<2>, devicen_layout_t<2>)
	204
	205	BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(8, uint8_t, dev3n, devicen_t<3>, devicen_layout_t<3>)
	206	BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(8s, int8_t, dev3n, devicen_t<3>, devicen_layout_t<3>)
	207	BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(16, uint16_t, dev3n, devicen_t<3>, devicen_layout_t<3>)
	208	BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(16s, int16_t, dev3n, devicen_t<3>, devicen_layout_t<3>)
	209	BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(32, uint32_t, dev3n, devicen_t<3>, devicen_layout_t<3>)
	210	BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(32s, int32_t, dev3n, devicen_t<3>, devicen_layout_t<3>)
	211	BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(32f, float32_t, dev3n, devicen_t<3>, devicen_layout_t<3>)
	212
	213	BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(8, uint8_t, dev4n, devicen_t<4>, devicen_layout_t<4>)
	214	BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(8s, int8_t, dev4n, devicen_t<4>, devicen_layout_t<4>)
	215	BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(16, uint16_t, dev4n, devicen_t<4>, devicen_layout_t<4>)
	216	BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(16s, int16_t, dev4n, devicen_t<4>, devicen_layout_t<4>)
	217	BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(32, uint32_t, dev4n, devicen_t<4>, devicen_layout_t<4>)
	218	BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(32s, int32_t, dev4n, devicen_t<4>, devicen_layout_t<4>)
	219	BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(32f, float32_t, dev4n, devicen_t<4>, devicen_layout_t<4>)
	220
	221	BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(8, uint8_t, dev5n, devicen_t<5>, devicen_layout_t<5>)
	222	BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(8s, int8_t, dev5n, devicen_t<5>, devicen_layout_t<5>)
	223	BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(16, uint16_t, dev5n, devicen_t<5>, devicen_layout_t<5>)
	224	BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(16s, int16_t, dev5n, devicen_t<5>, devicen_layout_t<5>)
	225	BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(32, uint32_t, dev5n, devicen_t<5>, devicen_layout_t<5>)
	226	BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(32s, int32_t, dev5n, devicen_t<5>, devicen_layout_t<5>)
	227	BOOST_GIL_DEFINE_ALL_TYPEDEFS_INTERNAL(32f, float32_t, dev5n, devicen_t<5>, devicen_layout_t<5>)
92f5a8d4 TL	228
92f5a8d4 TL	229	}} // namespace boost::gil
7c673cae FG	230
7c673cae FG	231	#endif