gil_concept.hpp Go to the documentation of this file. /* Copyright 2005-2007 Adobe Systems Incorporated 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). See http://opensource.adobe.com/gil for most recent version including documentation. */ /*************************************************************************************************/ #ifndef GIL_CONCEPT_H #define GIL_CONCEPT_H #include <functional> #include "gil_config.hpp" #include <boost/type_traits.hpp> #include <boost/utility/enable_if.hpp> #include <boost/concept_check.hpp> #include <boost/iterator/iterator_concepts.hpp> #include <boost/mpl/and.hpp> #include <boost/mpl/size.hpp> namespace boost { namespace gil { template <typename T> struct channel_traits; template <typename P> struct is_pixel; template <typename dstT, typename srcT> typename channel_traits<dstT>::value_type channel_convert(srcT val); template <typename T> class point2; template <std::size_t K, typename T> const T& axis_value(const point2<T>& p); template <std::size_t K, typename T> T& axis_value( point2<T>& p); template <typename ColorBase, int K> struct kth_element_type; template <typename ColorBase, int K> struct kth_element_reference_type; template <typename ColorBase, int K> struct kth_element_const_reference_type; template <typename ColorBase, int K> struct kth_semantic_element_reference_type; template <typename ColorBase, int K> struct kth_semantic_element_const_reference_type; template <typename ColorBase> struct size; template <typename ColorBase> struct element_type; template <typename T> struct channel_type; template <typename T> struct color_space_type; template <typename T> struct channel_mapping_type; template <typename T> struct is_planar; template <typename T> struct num_channels; template <typename It> struct const_iterator_type; template <typename It> struct iterator_is_mutable; template <typename It> struct is_iterator_adaptor; template <typename It, typename NewBaseIt> struct iterator_adaptor_rebind; template <typename It> struct iterator_adaptor_get_base; // forward-declare at_c namespace detail { template <typename Element, typename Layout, int K> struct homogeneous_color_base; } template <int K, typename E, typename L, int N> typename add_reference<E>::type at_c( detail::homogeneous_color_base<E,L,N>& p); template <int K, typename E, typename L, int N> typename add_reference<typename add_const<E>::type>::type at_c(const detail::homogeneous_color_base<E,L,N>& p); #if !defined(_MSC_VER) || _MSC_VER > 1310 template <typename P, typename C, typename L> struct packed_pixel; template <int K, typename P, typename C, typename L> typename kth_element_reference_type<packed_pixel<P,C,L>, K>::type at_c(packed_pixel<P,C,L>& p); template <int K, typename P, typename C, typename L> typename kth_element_const_reference_type<packed_pixel<P,C,L>,K>::type at_c(const packed_pixel<P,C,L>& p); template <typename C, typename L, bool M> struct bit_aligned_pixel_reference; template <int K, typename C, typename L, bool M> inline typename kth_element_reference_type<bit_aligned_pixel_reference<C,L,M>, K>::type at_c(const bit_aligned_pixel_reference<C,L,M>& p); #endif // Forward-declare semantic_at_c template <int K, typename ColorBase> typename disable_if<is_const<ColorBase>,typename kth_semantic_element_reference_type<ColorBase,K>::type>::type semantic_at_c(ColorBase& p); template <int K, typename ColorBase> typename kth_semantic_element_const_reference_type<ColorBase,K>::type semantic_at_c(const ColorBase& p); template <typename T> struct dynamic_x_step_type; template <typename T> struct dynamic_y_step_type; template <typename T> struct transposed_type; namespace detail { template <typename T> void initialize_it(T& x) {} } // namespace detail template <typename T> struct remove_const_and_reference : public remove_const<typename remove_reference<T>::type> {}; #ifdef BOOST_GIL_USE_CONCEPT_CHECK #define GIL_CLASS_REQUIRE(type_var, ns, concept) BOOST_CLASS_REQUIRE(type_var, ns, concept); template <typename C> void gil_function_requires() { function_requires<C>(); } #else #define GIL_CLASS_REQUIRE(T,NS,C) template <typename C> void gil_function_requires() {} #endif template <typename T> struct DefaultConstructible { void constraints() { function_requires<boost::DefaultConstructibleConcept<T> >(); } }; template <typename T> struct CopyConstructible { void constraints() { function_requires<boost::CopyConstructibleConcept<T> >(); } }; template <typename T> struct Assignable { void constraints() { function_requires<boost::AssignableConcept<T> >(); } }; template <typename T> struct EqualityComparable { void constraints() { function_requires<boost::EqualityComparableConcept<T> >(); } }; template <typename T, typename U> struct SameType { void constraints() { BOOST_STATIC_ASSERT((boost::is_same<T,U>::value_core)); } }; template <typename T> struct Swappable { void constraints() { using std::swap; swap(x,y); } T x,y; }; template <typename T> struct Regular { void constraints() { gil_function_requires< boost::DefaultConstructibleConcept<T> >(); gil_function_requires< boost::CopyConstructibleConcept<T> >(); gil_function_requires< boost::EqualityComparableConcept<T> >(); // ==, != gil_function_requires< boost::AssignableConcept<T> >(); gil_function_requires< Swappable<T> >(); } }; template <typename T> struct Metafunction { void constraints() { typedef typename T::type type; } }; // // POINT CONCEPTS // template <typename P> struct PointNDConcept { void constraints() { gil_function_requires< Regular<P> >(); typedef typename P::value_type value_type; static const std::size_t N=P::num_dimensions; ignore_unused_variable_warning(N); typedef typename P::template axis<0>::coord_t FT; typedef typename P::template axis<N-1>::coord_t LT; FT ft=gil::axis_value<0>(point); axis_value<0>(point)=ft; LT lt=axis_value<N-1>(point); axis_value<N-1>(point)=lt; value_type v=point[0]; ignore_unused_variable_warning(v); point[0]=point[0]; } P point; }; template <typename P> struct Point2DConcept { void constraints() { gil_function_requires< PointNDConcept<P> >(); BOOST_STATIC_ASSERT(P::num_dimensions == 2); point.x=point.y; point[0]=point[1]; } P point; }; // // ITERATOR MUTABILITY CONCEPTS // // Taken from boost's concept_check.hpp. Isolating mutability to result in faster compile time // namespace detail { template <class TT> // Preconditions: TT Models boost_concepts::ForwardTraversalConcept struct ForwardIteratorIsMutableConcept { void constraints() { *i++ = *i; // require postincrement and assignment } TT i; }; template <class TT> // Preconditions: TT Models boost::BidirectionalIteratorConcept struct BidirectionalIteratorIsMutableConcept { void constraints() { gil_function_requires< ForwardIteratorIsMutableConcept<TT> >(); *i-- = *i; // require postdecrement and assignment } TT i; }; template <class TT> // Preconditions: TT Models boost_concepts::RandomAccessTraversalConcept struct RandomAccessIteratorIsMutableConcept { void constraints() { gil_function_requires< BidirectionalIteratorIsMutableConcept<TT> >(); typename std::iterator_traits<TT>::difference_type n=0; ignore_unused_variable_warning(n); i[n] = *i; // require element access and assignment } TT i; }; } // namespace detail // // COLOR SPACE CONCEPTS // template <typename Cs> struct ColorSpaceConcept { void constraints() { // An MPL Random Access Sequence, whose elements are color tags } }; template <typename ColorSpace1, typename ColorSpace2> // Models ColorSpaceConcept struct color_spaces_are_compatible : public is_same<ColorSpace1,ColorSpace2> {}; template <typename Cs1, typename Cs2> struct ColorSpacesCompatibleConcept { void constraints() { BOOST_STATIC_ASSERT((color_spaces_are_compatible<Cs1,Cs2>::value)); } }; template <typename CM> struct ChannelMappingConcept { void constraints() { // An MPL Random Access Sequence, whose elements model MPLIntegralConstant representing a permutation } }; template <typename T> struct ChannelConcept { void constraints() { gil_function_requires< boost::EqualityComparableConcept<T> >(); typedef typename channel_traits<T>::value_type v; typedef typename channel_traits<T>::reference r; typedef typename channel_traits<T>::pointer p; typedef typename channel_traits<T>::const_reference cr; typedef typename channel_traits<T>::const_pointer cp; channel_traits<T>::min_value(); channel_traits<T>::max_value(); } T c; }; namespace detail { // Preconditions: T models ChannelConcept template <typename T> struct ChannelIsMutableConcept { void constraints() { c=c; using std::swap; swap(c,c); } T c; }; } template <typename T> struct MutableChannelConcept { void constraints() { gil_function_requires<ChannelConcept<T> >(); gil_function_requires<detail::ChannelIsMutableConcept<T> >(); } }; template <typename T> struct ChannelValueConcept { void constraints() { gil_function_requires<ChannelConcept<T> >(); gil_function_requires<Regular<T> >(); } }; template <typename T1, typename T2> // Models GIL Pixel struct channels_are_compatible : public is_same<typename channel_traits<T1>::value_type, typename channel_traits<T2>::value_type> {}; template <typename T1, typename T2> struct ChannelsCompatibleConcept { void constraints() { BOOST_STATIC_ASSERT((channels_are_compatible<T1,T2>::value)); } }; template <typename SrcChannel, typename DstChannel> struct ChannelConvertibleConcept { void constraints() { gil_function_requires<ChannelConcept<SrcChannel> >(); gil_function_requires<MutableChannelConcept<DstChannel> >(); dst=channel_convert<DstChannel,SrcChannel>(src); ignore_unused_variable_warning(dst); } SrcChannel src; DstChannel dst; }; template <typename ColorBase> struct ColorBaseConcept { void constraints() { gil_function_requires< CopyConstructible<ColorBase> >(); gil_function_requires< EqualityComparable<ColorBase> >(); typedef typename ColorBase::layout_t::color_space_t color_space_t; gil_function_requires<ColorSpaceConcept<color_space_t> >(); typedef typename ColorBase::layout_t::channel_mapping_t channel_mapping_t; // TODO: channel_mapping_t must be an MPL RandomAccessSequence static const std::size_t num_elements = size<ColorBase>::value; typedef typename kth_element_type<ColorBase,num_elements-1>::type TN; typedef typename kth_element_const_reference_type<ColorBase,num_elements-1>::type CR; #if !defined(_MSC_VER) || _MSC_VER > 1310 CR cr=at_c<num_elements-1>(cb); ignore_unused_variable_warning(cr); #endif // 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; }; template <typename ColorBase> struct MutableColorBaseConcept { void constraints() { gil_function_requires< ColorBaseConcept<ColorBase> >(); gil_function_requires< Assignable<ColorBase> >(); gil_function_requires< Swappable<ColorBase> >(); typedef typename kth_element_reference_type<ColorBase, 0>::type CR; #if !defined(_MSC_VER) || _MSC_VER > 1310 CR r=at_c<0>(cb); at_c<0>(cb)=r; #endif } ColorBase cb; }; template <typename ColorBase> struct ColorBaseValueConcept { void constraints() { gil_function_requires< MutableColorBaseConcept<ColorBase> >(); gil_function_requires< Regular<ColorBase> >(); } }; template <typename ColorBase> struct HomogeneousColorBaseConcept { void constraints() { gil_function_requires< ColorBaseConcept<ColorBase> >(); static const std::size_t num_elements = size<ColorBase>::value; typedef typename kth_element_type<ColorBase,0>::type T0; typedef typename kth_element_type<ColorBase,num_elements-1>::type TN; BOOST_STATIC_ASSERT((is_same<T0,TN>::value)); // better than nothing typedef typename kth_element_const_reference_type<ColorBase,0>::type CR0; CR0 e0=dynamic_at_c(cb,0); } ColorBase cb; }; template <typename ColorBase> struct MutableHomogeneousColorBaseConcept { void constraints() { gil_function_requires< ColorBaseConcept<ColorBase> >(); gil_function_requires< HomogeneousColorBaseConcept<ColorBase> >(); typedef typename kth_element_reference_type<ColorBase, 0>::type R0; R0 x=dynamic_at_c(cb,0); dynamic_at_c(cb,0) = dynamic_at_c(cb,0); } ColorBase cb; }; template <typename ColorBase> struct HomogeneousColorBaseValueConcept { void constraints() { gil_function_requires< MutableHomogeneousColorBaseConcept<ColorBase> >(); gil_function_requires< Regular<ColorBase> >(); } }; template <typename ColorBase1, typename ColorBase2> struct ColorBasesCompatibleConcept { void constraints() { BOOST_STATIC_ASSERT((is_same<typename ColorBase1::layout_t::color_space_t, typename ColorBase2::layout_t::color_space_t>::value)); // typedef typename kth_semantic_element_type<ColorBase1,0>::type e1; // typedef typename kth_semantic_element_type<ColorBase2,0>::type e2; // "e1 is convertible to e2" } }; template <typename P> struct PixelBasedConcept { void constraints() { typedef typename color_space_type<P>::type color_space_t; gil_function_requires<ColorSpaceConcept<color_space_t> >(); typedef typename channel_mapping_type<P>::type channel_mapping_t; gil_function_requires<ChannelMappingConcept<channel_mapping_t> >(); static const bool planar = is_planar<P>::type::value; ignore_unused_variable_warning(planar); // This is not part of the concept, but should still work static const std::size_t nc = num_channels<P>::value; ignore_unused_variable_warning(nc); } }; template <typename P> struct HomogeneousPixelBasedConcept { void constraints() { gil_function_requires<PixelBasedConcept<P> >(); typedef typename channel_type<P>::type channel_t; gil_function_requires<ChannelConcept<channel_t> >(); } }; template <typename P> struct PixelConcept { void constraints() { gil_function_requires<ColorBaseConcept<P> >(); gil_function_requires<PixelBasedConcept<P> >(); BOOST_STATIC_ASSERT((is_pixel<P>::value)); static const bool is_mutable = P::is_mutable; ignore_unused_variable_warning(is_mutable); typedef typename P::value_type value_type; // gil_function_requires<PixelValueConcept<value_type> >(); typedef typename P::reference reference; gil_function_requires<PixelConcept<typename remove_const_and_reference<reference>::type> >(); typedef typename P::const_reference const_reference; gil_function_requires<PixelConcept<typename remove_const_and_reference<const_reference>::type> >(); } }; template <typename P> struct MutablePixelConcept { void constraints() { gil_function_requires<PixelConcept<P> >(); BOOST_STATIC_ASSERT(P::is_mutable); } }; template <typename P> struct HomogeneousPixelConcept { void constraints() { gil_function_requires<PixelConcept<P> >(); gil_function_requires<HomogeneousColorBaseConcept<P> >(); gil_function_requires<HomogeneousPixelBasedConcept<P> >(); p[0]; } P p; }; template <typename P> struct MutableHomogeneousPixelConcept { void constraints() { gil_function_requires<HomogeneousPixelConcept<P> >(); gil_function_requires<MutableHomogeneousColorBaseConcept<P> >(); p[0]=p[0]; } P p; }; template <typename P> struct PixelValueConcept { void constraints() { gil_function_requires<PixelConcept<P> >(); gil_function_requires<Regular<P> >(); } }; template <typename P> struct HomogeneousPixelValueConcept { void constraints() { gil_function_requires<HomogeneousPixelConcept<P> >(); gil_function_requires<Regular<P> >(); BOOST_STATIC_ASSERT((is_same<P, typename P::value_type>::value)); } }; namespace detail { template <typename P1, typename P2, int K> struct channels_are_pairwise_compatible : public mpl::and_<channels_are_pairwise_compatible<P1,P2,K-1>, channels_are_compatible<typename kth_semantic_element_reference_type<P1,K>::type, typename kth_semantic_element_reference_type<P2,K>::type> > {}; template <typename P1, typename P2> struct channels_are_pairwise_compatible<P1,P2,-1> : public mpl::true_ {}; } template <typename P1, typename P2> // Models GIL Pixel struct pixels_are_compatible : public mpl::and_<typename color_spaces_are_compatible<typename color_space_type<P1>::type, typename color_space_type<P2>::type>::type, detail::channels_are_pairwise_compatible<P1,P2,num_channels<P1>::value-1> > {}; template <typename P1, typename P2> // precondition: P1 and P2 model PixelConcept struct PixelsCompatibleConcept { void constraints() { BOOST_STATIC_ASSERT((pixels_are_compatible<P1,P2>::value)); } }; template <typename SrcP, typename DstP> struct PixelConvertibleConcept { void constraints() { gil_function_requires<PixelConcept<SrcP> >(); gil_function_requires<MutablePixelConcept<DstP> >(); color_convert(src,dst); } SrcP src; DstP dst; }; template <typename D> struct PixelDereferenceAdaptorConcept { void constraints() { gil_function_requires< boost::UnaryFunctionConcept<D, typename remove_const_and_reference<typename D::result_type>::type, typename D::argument_type> >(); gil_function_requires< boost::DefaultConstructibleConcept<D> >(); gil_function_requires< boost::CopyConstructibleConcept<D> >(); gil_function_requires< boost::AssignableConcept<D> >(); gil_function_requires<PixelConcept<typename remove_const_and_reference<typename D::result_type>::type> >(); typedef typename D::const_t const_t; gil_function_requires<PixelDereferenceAdaptorConcept<const_t> >(); typedef typename D::value_type value_type; gil_function_requires<PixelValueConcept<value_type> >(); typedef typename D::reference reference; // == PixelConcept (if you remove const and reference) typedef typename D::const_reference const_reference; // == PixelConcept (if you remove const and reference) const bool is_mutable=D::is_mutable; ignore_unused_variable_warning(is_mutable); } D d; }; template <typename P> struct PixelDereferenceAdaptorArchetype : public std::unary_function<P, P> { typedef PixelDereferenceAdaptorArchetype const_t; typedef typename remove_reference<P>::type value_type; typedef typename add_reference<P>::type reference; typedef reference const_reference; static const bool is_mutable=false; P operator()(P x) const { throw; } }; template <typename T> struct HasDynamicXStepTypeConcept { void constraints() { typedef typename dynamic_x_step_type<T>::type type; } }; template <typename T> struct HasDynamicYStepTypeConcept { void constraints() { typedef typename dynamic_y_step_type<T>::type type; } }; template <typename T> struct HasTransposedTypeConcept { void constraints() { typedef typename transposed_type<T>::type type; } }; template <typename Iterator> struct PixelIteratorConcept { void constraints() { gil_function_requires<boost_concepts::RandomAccessTraversalConcept<Iterator> >(); gil_function_requires<PixelBasedConcept<Iterator> >(); typedef typename std::iterator_traits<Iterator>::value_type value_type; gil_function_requires<PixelValueConcept<value_type> >(); typedef typename const_iterator_type<Iterator>::type const_t; static const bool is_mut = iterator_is_mutable<Iterator>::type::value; ignore_unused_variable_warning(is_mut); const_t const_it(it); ignore_unused_variable_warning(const_it); // immutable iterator must be constructible from (possibly mutable) iterator check_base(typename is_iterator_adaptor<Iterator>::type()); } void check_base(mpl::false_) {} void check_base(mpl::true_) { typedef typename iterator_adaptor_get_base<Iterator>::type base_t; gil_function_requires<PixelIteratorConcept<base_t> >(); } Iterator it; }; namespace detail { template <typename Iterator> // Preconditions: Iterator Models PixelIteratorConcept struct PixelIteratorIsMutableConcept { void constraints() { gil_function_requires<detail::RandomAccessIteratorIsMutableConcept<Iterator> >(); typedef typename remove_reference<typename std::iterator_traits<Iterator>::reference>::type ref; typedef typename element_type<ref>::type channel_t; gil_function_requires<detail::ChannelIsMutableConcept<channel_t> >(); } }; } template <typename Iterator> struct MutablePixelIteratorConcept { void constraints() { gil_function_requires<PixelIteratorConcept<Iterator> >(); gil_function_requires<detail::PixelIteratorIsMutableConcept<Iterator> >(); } }; namespace detail { // Iterators that can be used as the base of memory_based_step_iterator require some additional functions template <typename Iterator> // Preconditions: Iterator Models boost_concepts::RandomAccessTraversalConcept struct RandomAccessIteratorIsMemoryBasedConcept { void constraints() { std::ptrdiff_t bs=memunit_step(it); ignore_unused_variable_warning(bs); it=memunit_advanced(it,3); std::ptrdiff_t bd=memunit_distance(it,it); ignore_unused_variable_warning(bd); memunit_advance(it,3); // for performace you may also provide a customized implementation of memunit_advanced_ref } Iterator it; }; } template <typename Iterator> struct MemoryBasedIteratorConcept { void constraints() { gil_function_requires<boost_concepts::RandomAccessTraversalConcept<Iterator> >(); gil_function_requires<detail::RandomAccessIteratorIsMemoryBasedConcept<Iterator> >(); } }; template <typename Iterator> struct StepIteratorConcept { void constraints() { gil_function_requires<boost_concepts::ForwardTraversalConcept<Iterator> >(); it.set_step(0); } Iterator it; }; template <typename Iterator> struct MutableStepIteratorConcept { void constraints() { gil_function_requires<StepIteratorConcept<Iterator> >(); gil_function_requires<detail::ForwardIteratorIsMutableConcept<Iterator> >(); } }; template <typename Iterator> struct IteratorAdaptorConcept { void constraints() { gil_function_requires<boost_concepts::ForwardTraversalConcept<Iterator> >(); typedef typename iterator_adaptor_get_base<Iterator>::type base_t; gil_function_requires<boost_concepts::ForwardTraversalConcept<base_t> >(); BOOST_STATIC_ASSERT(is_iterator_adaptor<Iterator>()); typedef typename iterator_adaptor_rebind<Iterator, void*>::type rebind_t; base_t base=it.base(); ignore_unused_variable_warning(base); } Iterator it; }; template <typename Iterator> struct MutableIteratorAdaptorConcept { void constraints() { gil_function_requires<IteratorAdaptorConcept<Iterator> >(); gil_function_requires<detail::ForwardIteratorIsMutableConcept<Iterator> >(); } }; template <typename Loc> struct RandomAccessNDLocatorConcept { void constraints() { gil_function_requires< Regular<Loc> >(); typedef typename Loc::value_type value_type; typedef typename Loc::reference reference; // result of dereferencing typedef typename Loc::difference_type difference_type; // result of operator-(pixel_locator, pixel_locator) typedef typename Loc::cached_location_t cached_location_t; // type used to store relative location (to allow for more efficient repeated access) typedef typename Loc::const_t const_t; // same as this type, but over const values typedef typename Loc::point_t point_t; // same as difference_type static const std::size_t N=Loc::num_dimensions; ignore_unused_variable_warning(N); typedef typename Loc::template axis<0>::iterator first_it_type; typedef typename Loc::template axis<N-1>::iterator last_it_type; gil_function_requires<boost_concepts::RandomAccessTraversalConcept<first_it_type> >(); gil_function_requires<boost_concepts::RandomAccessTraversalConcept<last_it_type> >(); // point_t must be an N-dimensional point, each dimension of which must have the same type as difference_type of the corresponding iterator gil_function_requires<PointNDConcept<point_t> >(); BOOST_STATIC_ASSERT(point_t::num_dimensions==N); BOOST_STATIC_ASSERT((is_same<typename std::iterator_traits<first_it_type>::difference_type, typename point_t::template axis<0>::coord_t>::value)); BOOST_STATIC_ASSERT((is_same<typename std::iterator_traits<last_it_type>::difference_type, typename point_t::template axis<N-1>::coord_t>::value)); difference_type d; loc+=d; loc-=d; loc=loc+d; loc=loc-d; reference r1=loc[d]; ignore_unused_variable_warning(r1); reference r2=*loc; ignore_unused_variable_warning(r2); cached_location_t cl=loc.cache_location(d); ignore_unused_variable_warning(cl); reference r3=loc[d]; ignore_unused_variable_warning(r3); first_it_type fi=loc.template axis_iterator<0>(); fi=loc.template axis_iterator<0>(d); last_it_type li=loc.template axis_iterator<N-1>(); li=loc.template axis_iterator<N-1>(d); typedef PixelDereferenceAdaptorArchetype<typename Loc::value_type> deref_t; typedef typename Loc::template add_deref<deref_t>::type dtype; //gil_function_requires<RandomAccessNDLocatorConcept<dtype> >(); // infinite recursion } Loc loc; }; template <typename Loc> struct RandomAccess2DLocatorConcept { void constraints() { gil_function_requires<RandomAccessNDLocatorConcept<Loc> >(); BOOST_STATIC_ASSERT(Loc::num_dimensions==2); typedef typename dynamic_x_step_type<Loc>::type dynamic_x_step_t; typedef typename dynamic_y_step_type<Loc>::type dynamic_y_step_t; typedef typename transposed_type<Loc>::type transposed_t; typedef typename Loc::cached_location_t cached_location_t; gil_function_requires<Point2DConcept<typename Loc::point_t> >(); typedef typename Loc::x_iterator x_iterator; typedef typename Loc::y_iterator y_iterator; typedef typename Loc::x_coord_t x_coord_t; typedef typename Loc::y_coord_t y_coord_t; x_coord_t xd=0; ignore_unused_variable_warning(xd); y_coord_t yd=0; ignore_unused_variable_warning(yd); typename Loc::difference_type d; typename Loc::reference r=loc(xd,yd); ignore_unused_variable_warning(r); dynamic_x_step_t loc2(dynamic_x_step_t(), yd); dynamic_x_step_t loc3(dynamic_x_step_t(), xd, yd); typedef typename dynamic_y_step_type<typename dynamic_x_step_type<transposed_t>::type>::type dynamic_xy_step_transposed_t; dynamic_xy_step_transposed_t loc4(loc, xd,yd,true); bool is_contiguous=loc.is_1d_traversable(xd); ignore_unused_variable_warning(is_contiguous); loc.y_distance_to(loc, xd); loc=loc.xy_at(d); loc=loc.xy_at(xd,yd); x_iterator xit=loc.x_at(d); xit=loc.x_at(xd,yd); xit=loc.x(); y_iterator yit=loc.y_at(d); yit=loc.y_at(xd,yd); yit=loc.y(); cached_location_t cl=loc.cache_location(xd,yd); ignore_unused_variable_warning(cl); } Loc loc; }; template <typename Loc> struct PixelLocatorConcept { void constraints() { gil_function_requires< RandomAccess2DLocatorConcept<Loc> >(); gil_function_requires< PixelIteratorConcept<typename Loc::x_iterator> >(); gil_function_requires< PixelIteratorConcept<typename Loc::y_iterator> >(); typedef typename Loc::coord_t coord_t; BOOST_STATIC_ASSERT((is_same<typename Loc::x_coord_t, typename Loc::y_coord_t>::value)); } Loc loc; }; namespace detail { template <typename Loc> // preconditions: Loc Models RandomAccessNDLocatorConcept struct RandomAccessNDLocatorIsMutableConcept { void constraints() { gil_function_requires<detail::RandomAccessIteratorIsMutableConcept<typename Loc::template axis<0>::iterator> >(); gil_function_requires<detail::RandomAccessIteratorIsMutableConcept<typename Loc::template axis<Loc::num_dimensions-1>::iterator> >(); typename Loc::difference_type d; initialize_it(d); typename Loc::value_type v;initialize_it(v); typename Loc::cached_location_t cl=loc.cache_location(d); *loc=v; loc[d]=v; loc[cl]=v; } Loc loc; }; template <typename Loc> // preconditions: Loc Models RandomAccess2DLocatorConcept struct RandomAccess2DLocatorIsMutableConcept { void constraints() { gil_function_requires<detail::RandomAccessNDLocatorIsMutableConcept<Loc> >(); typename Loc::x_coord_t xd=0; ignore_unused_variable_warning(xd); typename Loc::y_coord_t yd=0; ignore_unused_variable_warning(yd); typename Loc::value_type v; initialize_it(v); loc(xd,yd)=v; } Loc loc; }; } template <typename Loc> struct MutableRandomAccessNDLocatorConcept { void constraints() { gil_function_requires<RandomAccessNDLocatorConcept<Loc> >(); gil_function_requires<detail::RandomAccessNDLocatorIsMutableConcept<Loc> >(); } }; template <typename Loc> struct MutableRandomAccess2DLocatorConcept { void constraints() { gil_function_requires< RandomAccess2DLocatorConcept<Loc> >(); gil_function_requires<detail::RandomAccess2DLocatorIsMutableConcept<Loc> >(); } }; template <typename Loc> struct MutablePixelLocatorConcept { void constraints() { gil_function_requires<PixelLocatorConcept<Loc> >(); gil_function_requires<detail::RandomAccess2DLocatorIsMutableConcept<Loc> >(); } }; template <typename View> struct RandomAccessNDImageViewConcept { void constraints() { gil_function_requires< Regular<View> >(); typedef typename View::value_type value_type; typedef typename View::reference reference; // result of dereferencing typedef typename View::difference_type difference_type; // result of operator-(1d_iterator,1d_iterator) typedef typename View::const_t const_t; // same as this type, but over const values typedef typename View::point_t point_t; // N-dimensional point typedef typename View::locator locator; // N-dimensional locator typedef typename View::iterator iterator; typedef typename View::reverse_iterator reverse_iterator; typedef typename View::size_type size_type; static const std::size_t N=View::num_dimensions; gil_function_requires<RandomAccessNDLocatorConcept<locator> >(); gil_function_requires<boost_concepts::RandomAccessTraversalConcept<iterator> >(); gil_function_requires<boost_concepts::RandomAccessTraversalConcept<reverse_iterator> >(); typedef typename View::template axis<0>::iterator first_it_type; typedef typename View::template axis<N-1>::iterator last_it_type; gil_function_requires<boost_concepts::RandomAccessTraversalConcept<first_it_type> >(); gil_function_requires<boost_concepts::RandomAccessTraversalConcept<last_it_type> >(); // BOOST_STATIC_ASSERT((typename std::iterator_traits<first_it_type>::difference_type, typename point_t::template axis<0>::coord_t>::value)); // BOOST_STATIC_ASSERT((typename std::iterator_traits< last_it_type>::difference_type, typename point_t::template axis<N-1>::coord_t>::value)); // point_t must be an N-dimensional point, each dimension of which must have the same type as difference_type of the corresponding iterator gil_function_requires<PointNDConcept<point_t> >(); BOOST_STATIC_ASSERT(point_t::num_dimensions==N); BOOST_STATIC_ASSERT((is_same<typename std::iterator_traits<first_it_type>::difference_type, typename point_t::template axis<0>::coord_t>::value)); BOOST_STATIC_ASSERT((is_same<typename std::iterator_traits<last_it_type>::difference_type, typename point_t::template axis<N-1>::coord_t>::value)); point_t p; locator lc; iterator it; reverse_iterator rit; difference_type d; detail::initialize_it(d); ignore_unused_variable_warning(d); View(p,lc); // view must be constructible from a locator and a point p=view.dimensions(); lc=view.pixels(); size_type sz=view.size(); ignore_unused_variable_warning(sz); bool is_contiguous=view.is_1d_traversable(); ignore_unused_variable_warning(is_contiguous); it=view.begin(); it=view.end(); rit=view.rbegin(); rit=view.rend(); reference r1=view[d]; ignore_unused_variable_warning(r1); // 1D access reference r2=view(p); ignore_unused_variable_warning(r2); // 2D access // get 1-D iterator of any dimension at a given pixel location first_it_type fi=view.template axis_iterator<0>(p); ignore_unused_variable_warning(fi); last_it_type li=view.template axis_iterator<N-1>(p); ignore_unused_variable_warning(li); typedef PixelDereferenceAdaptorArchetype<typename View::value_type> deref_t; typedef typename View::template add_deref<deref_t>::type dtype; } View view; }; template <typename View> struct RandomAccess2DImageViewConcept { void constraints() { gil_function_requires<RandomAccessNDImageViewConcept<View> >(); BOOST_STATIC_ASSERT(View::num_dimensions==2); // TODO: This executes the requirements for RandomAccessNDLocatorConcept again. Fix it to improve compile time gil_function_requires<RandomAccess2DLocatorConcept<typename View::locator> >(); typedef typename dynamic_x_step_type<View>::type dynamic_x_step_t; typedef typename dynamic_y_step_type<View>::type dynamic_y_step_t; typedef typename transposed_type<View>::type transposed_t; typedef typename View::x_iterator x_iterator; typedef typename View::y_iterator y_iterator; typedef typename View::x_coord_t x_coord_t; typedef typename View::y_coord_t y_coord_t; typedef typename View::xy_locator xy_locator; x_coord_t xd=0; ignore_unused_variable_warning(xd); y_coord_t yd=0; ignore_unused_variable_warning(yd); x_iterator xit; y_iterator yit; typename View::point_t d; View(xd,yd,xy_locator()); // constructible with width, height, 2d_locator xy_locator lc=view.xy_at(xd,yd); lc=view.xy_at(d); typename View::reference r=view(xd,yd); ignore_unused_variable_warning(r); xd=view.width(); yd=view.height(); xit=view.x_at(d); xit=view.x_at(xd,yd); xit=view.row_begin(xd); xit=view.row_end(xd); yit=view.y_at(d); yit=view.y_at(xd,yd); yit=view.col_begin(xd); yit=view.col_end(xd); } View view; }; template <typename View> struct ImageViewConcept { void constraints() { gil_function_requires<RandomAccess2DImageViewConcept<View> >(); // TODO: This executes the requirements for RandomAccess2DLocatorConcept again. Fix it to improve compile time gil_function_requires<PixelLocatorConcept<typename View::xy_locator> >(); BOOST_STATIC_ASSERT((is_same<typename View::x_coord_t, typename View::y_coord_t>::value)); typedef typename View::coord_t coord_t; // 1D difference type (same for all dimensions) std::size_t num_chan = view.num_channels(); ignore_unused_variable_warning(num_chan); } View view; }; namespace detail { template <typename View> // Preconditions: View Models RandomAccessNDImageViewConcept struct RandomAccessNDImageViewIsMutableConcept { void constraints() { gil_function_requires<detail::RandomAccessNDLocatorIsMutableConcept<typename View::locator> >(); gil_function_requires<detail::RandomAccessIteratorIsMutableConcept<typename View::iterator> >(); gil_function_requires<detail::RandomAccessIteratorIsMutableConcept<typename View::reverse_iterator> >(); gil_function_requires<detail::RandomAccessIteratorIsMutableConcept<typename View::template axis<0>::iterator> >(); gil_function_requires<detail::RandomAccessIteratorIsMutableConcept<typename View::template axis<View::num_dimensions-1>::iterator> >(); typename View::difference_type diff; initialize_it(diff); ignore_unused_variable_warning(diff); typename View::point_t pt; typename View::value_type v; initialize_it(v); view[diff]=v; view(pt)=v; } View view; }; template <typename View> // preconditions: View Models RandomAccessNDImageViewConcept struct RandomAccess2DImageViewIsMutableConcept { void constraints() { gil_function_requires<detail::RandomAccessNDImageViewIsMutableConcept<View> >(); typename View::x_coord_t xd=0; ignore_unused_variable_warning(xd); typename View::y_coord_t yd=0; ignore_unused_variable_warning(yd); typename View::value_type v; initialize_it(v); view(xd,yd)=v; } View view; }; template <typename View> // preconditions: View Models ImageViewConcept struct PixelImageViewIsMutableConcept { void constraints() { gil_function_requires<detail::RandomAccess2DImageViewIsMutableConcept<View> >(); } }; } template <typename View> struct MutableRandomAccessNDImageViewConcept { void constraints() { gil_function_requires<RandomAccessNDImageViewConcept<View> >(); gil_function_requires<detail::RandomAccessNDImageViewIsMutableConcept<View> >(); } }; template <typename View> struct MutableRandomAccess2DImageViewConcept { void constraints() { gil_function_requires<RandomAccess2DImageViewConcept<View> >(); gil_function_requires<detail::RandomAccess2DImageViewIsMutableConcept<View> >(); } }; template <typename View> struct MutableImageViewConcept { void constraints() { gil_function_requires<ImageViewConcept<View> >(); gil_function_requires<detail::PixelImageViewIsMutableConcept<View> >(); } }; template <typename V1, typename V2> // Model ImageViewConcept struct views_are_compatible : public pixels_are_compatible<typename V1::value_type, typename V2::value_type> {}; template <typename V1, typename V2> struct ViewsCompatibleConcept { void constraints() { BOOST_STATIC_ASSERT((views_are_compatible<V1,V2>::value)); } }; template <typename Img> struct RandomAccessNDImageConcept { void constraints() { gil_function_requires<Regular<Img> >(); typedef typename Img::view_t view_t; gil_function_requires<MutableRandomAccessNDImageViewConcept<view_t> >(); typedef typename Img::const_view_t const_view_t; typedef typename Img::value_type pixel_t; typedef typename Img::point_t point_t; gil_function_requires<PointNDConcept<point_t> >(); const_view_t cv = const_view(img); ignore_unused_variable_warning(cv); view_t v = view(img); ignore_unused_variable_warning(v); pixel_t fill_value; point_t pt=img.dimensions(); Img im1(pt); Img im2(pt,1); Img im3(pt,fill_value,1); img.recreate(pt); img.recreate(pt,1); img.recreate(pt,fill_value,1); } Img img; }; template <typename Img> struct RandomAccess2DImageConcept { void constraints() { gil_function_requires<RandomAccessNDImageConcept<Img> >(); typedef typename Img::x_coord_t x_coord_t; typedef typename Img::y_coord_t y_coord_t; typedef typename Img::value_type value_t; gil_function_requires<MutableRandomAccess2DImageViewConcept<typename Img::view_t> >(); x_coord_t w=img.width(); y_coord_t h=img.height(); value_t fill_value; Img im1(w,h); Img im2(w,h,1); Img im3(w,h,fill_value,1); img.recreate(w,h); img.recreate(w,h,1); img.recreate(w,h,fill_value,1); } Img img; }; template <typename Img> struct ImageConcept { void constraints() { gil_function_requires<RandomAccess2DImageConcept<Img> >(); gil_function_requires<MutableImageViewConcept<typename Img::view_t> >(); typedef typename Img::coord_t coord_t; BOOST_STATIC_ASSERT(num_channels<Img>::value == mpl::size<typename color_space_type<Img>::type>::value); BOOST_STATIC_ASSERT((is_same<coord_t, typename Img::x_coord_t>::value)); BOOST_STATIC_ASSERT((is_same<coord_t, typename Img::y_coord_t>::value)); } Img img; }; } } // namespace boost::gil #endif

• Company | 
• Online Privacy Policy | 
• Terms of Use | 
• Contact Us | 
• Accessibility | 
• Report Piracy | 
• Permissions & Trademarks | 
• Product License Agreements | 
• Send Feedback

Copyright © 2006-2007 Adobe Systems Incorporated.

Use of this website signifies your agreement to the Terms of Use and Online Privacy Policy.

Search powered by Google