123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328 |
- //
- // Copyright 2005-2007 Adobe Systems Incorporated
- //
- // 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_CONCEPTS_COLOR_BASE_HPP
- #define BOOST_GIL_CONCEPTS_COLOR_BASE_HPP
- #include <boost/gil/concepts/basic.hpp>
- #include <boost/gil/concepts/color.hpp>
- #include <boost/gil/concepts/concept_check.hpp>
- #include <boost/gil/concepts/fwd.hpp>
- #include <boost/core/ignore_unused.hpp>
- #include <type_traits>
- #if defined(BOOST_CLANG)
- #pragma clang diagnostic push
- #pragma clang diagnostic ignored "-Wunused-local-typedefs"
- #endif
- #if defined(BOOST_GCC) && (BOOST_GCC >= 40900)
- #pragma GCC diagnostic push
- #pragma GCC diagnostic ignored "-Wunused-local-typedefs"
- #endif
- namespace boost { namespace gil {
- // Forward declarations of at_c
- namespace detail {
- template <typename Element, typename Layout, int K>
- struct homogeneous_color_base;
- } // namespace detail
- template <int K, typename E, typename L, int N>
- auto at_c(detail::homogeneous_color_base<E, L, N>& p)
- -> typename std::add_lvalue_reference<E>::type;
- template <int K, typename E, typename L, int N>
- auto at_c(detail::homogeneous_color_base<E, L, N> const& p)
- -> typename std::add_lvalue_reference<typename std::add_const<E>::type>::type;
- template <typename P, typename C, typename L>
- struct packed_pixel;
- template <int K, typename P, typename C, typename L>
- auto at_c(packed_pixel<P, C, L>& p)
- -> typename kth_element_reference_type<packed_pixel<P, C, L>, K>::type;
- template <int K, typename P, typename C, typename L>
- auto at_c(packed_pixel<P, C, L> const& p)
- -> typename kth_element_const_reference_type<packed_pixel<P, C, L>, K>::type;
- template <typename B, typename C, typename L, bool M>
- struct bit_aligned_pixel_reference;
- template <int K, typename B, typename C, typename L, bool M>
- inline auto at_c(bit_aligned_pixel_reference<B, C, L, M> const& p)
- -> typename kth_element_reference_type
- <
- bit_aligned_pixel_reference<B, C, L, M>,
- K
- >::type;
- // Forward declarations of semantic_at_c
- template <int K, typename ColorBase>
- auto semantic_at_c(ColorBase& p)
- -> typename std::enable_if
- <
- !std::is_const<ColorBase>::value,
- typename kth_semantic_element_reference_type<ColorBase, K>::type
- >::type;
- template <int K, typename ColorBase>
- auto semantic_at_c(ColorBase const& p)
- -> typename kth_semantic_element_const_reference_type<ColorBase, K>::type;
- /// \ingroup ColorBaseConcept
- /// \brief A color base is a container of color elements (such as channels, channel references or channel pointers).
- ///
- /// The most common use of color base is in the implementation of a pixel,
- /// in which case the color elements are channel values. The color base concept,
- /// however, can be used in other scenarios. For example, a planar pixel has
- /// channels that are not contiguous in memory. Its reference is a proxy class
- /// that uses a color base whose elements are channel references. Its iterator
- /// uses a color base whose elements are channel iterators.
- ///
- /// A color base must have an associated layout (which consists of a color space,
- /// as well as an ordering of the channels).
- /// There are two ways to index the elements of a color base: A physical index
- /// corresponds to the way they are ordered in memory, and a semantic index
- /// corresponds to the way the elements are ordered in their color space.
- /// For example, in the RGB color space the elements are ordered as
- /// {red_t, green_t, blue_t}. For a color base with a BGR layout, the first element
- /// in physical ordering is the blue element, whereas the first semantic element
- /// is the red one.
- /// Models of \p ColorBaseConcept are required to provide the \p at_c<K>(ColorBase)
- /// function, which allows for accessing the elements based on their physical order.
- /// GIL provides a \p semantic_at_c<K>(ColorBase) function (described later)
- /// which can operate on any model of ColorBaseConcept and returns the corresponding
- /// semantic element.
- ///
- /// \code
- /// concept ColorBaseConcept<typename T> : CopyConstructible<T>, EqualityComparable<T>
- /// {
- /// // a GIL layout (the color space and element permutation)
- /// typename layout_t;
- ///
- /// // The type of K-th element
- /// template <int K>
- /// struct kth_element_type;
- /// where Metafunction<kth_element_type>;
- ///
- /// // The result of at_c
- /// template <int K>
- /// struct kth_element_const_reference_type;
- /// where Metafunction<kth_element_const_reference_type>;
- ///
- /// template <int K>
- /// kth_element_const_reference_type<T,K>::type at_c(T);
- ///
- /// // Copy-constructible and equality comparable with other compatible color bases
- /// template <ColorBaseConcept T2> where { ColorBasesCompatibleConcept<T,T2> }
- /// T::T(T2);
- /// template <ColorBaseConcept T2> where { ColorBasesCompatibleConcept<T,T2> }
- /// bool operator==(const T&, const T2&);
- /// template <ColorBaseConcept T2> where { ColorBasesCompatibleConcept<T,T2> }
- /// bool operator!=(const T&, const T2&);
- /// };
- /// \endcode
- template <typename ColorBase>
- struct ColorBaseConcept
- {
- void constraints()
- {
- gil_function_requires<CopyConstructible<ColorBase>>();
- gil_function_requires<EqualityComparable<ColorBase>>();
- using color_space_t = typename ColorBase::layout_t::color_space_t;
- gil_function_requires<ColorSpaceConcept<color_space_t>>();
- using channel_mapping_t = typename ColorBase::layout_t::channel_mapping_t;
- // TODO: channel_mapping_t must be an Boost.MP11-compatible random access sequence
- static const int num_elements = size<ColorBase>::value;
- using TN = typename kth_element_type<ColorBase, num_elements - 1>::type;
- using RN = typename kth_element_const_reference_type<ColorBase, num_elements - 1>::type;
- RN r = gil::at_c<num_elements - 1>(cb);
- boost::ignore_unused(r);
- // functions that work for every pixel (no need to require them)
- semantic_at_c<0>(cb);
- semantic_at_c<num_elements-1>(cb);
- // also static_max(cb), static_min(cb), static_fill(cb,value),
- // and all variations of static_for_each(), static_generate(), static_transform()
- }
- ColorBase cb;
- };
- /// \ingroup ColorBaseConcept
- /// \brief Color base which allows for modifying its elements
- /// \code
- /// concept MutableColorBaseConcept<ColorBaseConcept T> : Assignable<T>, Swappable<T>
- /// {
- /// template <int K>
- /// struct kth_element_reference_type; where Metafunction<kth_element_reference_type>;
- ///
- /// template <int K>
- /// kth_element_reference_type<kth_element_type<T,K>::type>::type at_c(T);
- ///
- /// template <ColorBaseConcept T2> where { ColorBasesCompatibleConcept<T,T2> }
- /// T& operator=(T&, const T2&);
- /// };
- /// \endcode
- template <typename ColorBase>
- struct MutableColorBaseConcept
- {
- void constraints()
- {
- gil_function_requires<ColorBaseConcept<ColorBase>>();
- gil_function_requires<Assignable<ColorBase>>();
- gil_function_requires<Swappable<ColorBase>>();
- using R0 = typename kth_element_reference_type<ColorBase, 0>::type;
- R0 r = gil::at_c<0>(cb);
- gil::at_c<0>(cb) = r;
- }
- ColorBase cb;
- };
- /// \ingroup ColorBaseConcept
- /// \brief Color base that also has a default-constructor. Refines Regular
- /// \code
- /// concept ColorBaseValueConcept<typename T> : MutableColorBaseConcept<T>, Regular<T>
- /// {
- /// };
- /// \endcode
- template <typename ColorBase>
- struct ColorBaseValueConcept
- {
- void constraints()
- {
- gil_function_requires<MutableColorBaseConcept<ColorBase>>();
- gil_function_requires<Regular<ColorBase>>();
- }
- };
- /// \ingroup ColorBaseConcept
- /// \brief Color base whose elements all have the same type
- /// \code
- /// concept HomogeneousColorBaseConcept<ColorBaseConcept CB>
- /// {
- /// // For all K in [0 ... size<C1>::value-1):
- /// // where SameType<kth_element_type<CB,K>::type, kth_element_type<CB,K+1>::type>;
- /// kth_element_const_reference_type<CB,0>::type dynamic_at_c(CB const&, std::size_t n) const;
- /// };
- /// \endcode
- template <typename ColorBase>
- struct HomogeneousColorBaseConcept
- {
- void constraints()
- {
- gil_function_requires<ColorBaseConcept<ColorBase>>();
- static const int num_elements = size<ColorBase>::value;
- using T0 = typename kth_element_type<ColorBase, 0>::type;
- using TN = typename kth_element_type<ColorBase, num_elements - 1>::type;
- static_assert(std::is_same<T0, TN>::value, ""); // better than nothing
- using R0 = typename kth_element_const_reference_type<ColorBase, 0>::type;
- R0 r = dynamic_at_c(cb, 0);
- boost::ignore_unused(r);
- }
- ColorBase cb;
- };
- /// \ingroup ColorBaseConcept
- /// \brief Homogeneous color base that allows for modifying its elements
- /// \code
- /// concept MutableHomogeneousColorBaseConcept<ColorBaseConcept CB>
- /// : HomogeneousColorBaseConcept<CB>
- /// {
- /// kth_element_reference_type<CB, 0>::type dynamic_at_c(CB&, std::size_t n);
- /// };
- /// \endcode
- template <typename ColorBase>
- struct MutableHomogeneousColorBaseConcept
- {
- void constraints()
- {
- gil_function_requires<ColorBaseConcept<ColorBase>>();
- gil_function_requires<HomogeneousColorBaseConcept<ColorBase>>();
- using R0 = typename kth_element_reference_type<ColorBase, 0>::type;
- R0 r = dynamic_at_c(cb, 0);
- boost::ignore_unused(r);
- dynamic_at_c(cb, 0) = dynamic_at_c(cb, 0);
- }
- ColorBase cb;
- };
- /// \ingroup ColorBaseConcept
- /// \brief Homogeneous color base that also has a default constructor.
- /// Refines Regular.
- ///
- /// \code
- /// concept HomogeneousColorBaseValueConcept<typename T>
- /// : MutableHomogeneousColorBaseConcept<T>, Regular<T>
- /// {
- /// };
- /// \endcode
- template <typename ColorBase>
- struct HomogeneousColorBaseValueConcept
- {
- void constraints()
- {
- gil_function_requires<MutableHomogeneousColorBaseConcept<ColorBase>>();
- gil_function_requires<Regular<ColorBase>>();
- }
- };
- /// \ingroup ColorBaseConcept
- /// \brief Two color bases are compatible if they have the same color space and their elements are compatible, semantic-pairwise.
- /// \code
- /// concept ColorBasesCompatibleConcept<ColorBaseConcept C1, ColorBaseConcept C2>
- /// {
- /// where SameType<C1::layout_t::color_space_t, C2::layout_t::color_space_t>;
- /// // also, for all K in [0 ... size<C1>::value):
- /// // where Convertible<kth_semantic_element_type<C1,K>::type, kth_semantic_element_type<C2,K>::type>;
- /// // where Convertible<kth_semantic_element_type<C2,K>::type, kth_semantic_element_type<C1,K>::type>;
- /// };
- /// \endcode
- template <typename ColorBase1, typename ColorBase2>
- struct ColorBasesCompatibleConcept
- {
- void constraints()
- {
- static_assert(std::is_same
- <
- typename ColorBase1::layout_t::color_space_t,
- typename ColorBase2::layout_t::color_space_t
- >::value, "");
- // using e1 = typename kth_semantic_element_type<ColorBase1,0>::type;
- // using e2 = typename kth_semantic_element_type<ColorBase2,0>::type;
- // "e1 is convertible to e2"
- }
- };
- }} // namespace boost::gil
- #if defined(BOOST_CLANG)
- #pragma clang diagnostic pop
- #endif
- #if defined(BOOST_GCC) && (BOOST_GCC >= 40900)
- #pragma GCC diagnostic pop
- #endif
- #endif
|