Information Home Overview Documentation Getting Started Release Notes ASL Wiki License Indices Success Stories Contributors Media Download ASL Perforce Depots Support ASL SourceForge Home Mailing Lists Discussion Forums Report Bugs Suggest Features Contributing to ASL RSS Short-text news Full-text news File releases Other Adobe Projects Adobe XMP Adobe Labs Other Resources Boost SGI STL

gil_concept.hpp Go to the documentation of this file. /* Copyright 2005-2006 Adobe Systems Incorporated Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt or a copy at http://opensource.adobe.com/licenses.html) */ /*************************************************************************************************/ #ifndef GIL_CONCEPT_H #define GIL_CONCEPT_H #include "gil_config.hpp" #include <boost/type_traits.hpp> #include <boost/concept_check.hpp> #include <boost/mpl/and.hpp> ADOBE_GIL_NAMESPACE_BEGIN template <typename T> struct channel_traits; template <typename PIT> struct pixel_iterator_traits; template <typename dstT, typename srcT> typename channel_traits<dstT>::value_type channel_convert(srcT val); #ifdef _MSC_VER #pragma warning(push) #pragma warning(disable : 4700) // local variable used without being initialized #endif #ifdef USE_GIL_CONCEPT_CHECK #define GIL_CLASS_REQUIRE(type_var, ns, concept) BOOST_CLASS_REQUIRE(type_var, ns, concept) template <typename C> void gil_function_requires() { boost::function_requires<C>(); } #else #define GIL_CLASS_REQUIRE(T,NS,C) template <typename C> void gil_function_requires() {} #endif template <typename T> struct ValueType { 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> >(); } }; // POINT CONCEPTS template <typename P> struct PointNDConcept { void constraints() { gil_function_requires< ValueType<P> >(); typedef typename P::value_type value_type; static const std::size_t N=P::num_dimensions; typedef typename P::template axis<0>::coord_t FT; typedef typename P::template axis<N-1>::coord_t LT; value_type v=point[0]; boost::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; } 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::ForwardIteratorConcept 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::RandomAccessIteratorConcept struct RandomAccessIteratorIsMutableConcept { void constraints() { gil_function_requires< BidirectionalIteratorIsMutableConcept<TT> >(); typename std::iterator_traits<TT>::difference_type n; i[n] = *i; // require element access and assignment } TT i; }; template <typename C> // prerequisites: IMG Models boost::RandomAccessContainerConcept struct RandomAccessContainerIsMutableConcept { void constraints() { gil_function_requires<boost::Mutable_RandomAccessContainerConcept<C> >(); // TODO: Fix } }; } // namespace detail template <typename CS> struct ColorSpaceTypeConcept { void constraints() { typedef typename CS::base base; int x=CS::num_channels; boost::ignore_unused_variable_warning(x); } }; template <typename C1, typename C2> // Models GIL Pixel struct color_spaces_are_compatible : public boost::is_same<typename C1::base,typename C2::base> {}; template <typename CS1, typename CS2> struct ColorSpacesCompatibleConcept { void constraints() { BOOST_STATIC_ASSERT((color_spaces_are_compatible<CS1,CS2>::value)); } }; template <typename T> struct ChannelConcept { void constraints() { gil_function_requires< boost::EqualityComparableConcept<T> >(); gil_function_requires< boost::LessThanComparableConcept<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; } T c; }; namespace detail { // Preconditions: T models ChannelConcept template <typename T> struct ChannelIsMutableConcept { void constraints() { 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<ValueType<T> >(); } }; template <typename T> struct MutableChannelValueConcept { void constraints() { gil_function_requires<ChannelValueConcept<T> >(); gil_function_requires<detail::ChannelIsMutableConcept<T> >(); } }; template <typename T1, typename T2> // Models GIL Pixel struct channels_are_compatible : public boost::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 SRC_T, typename DST_T> struct ChannelConvertibleConcept { void constraints() { gil_function_requires<ChannelConcept<SRC_T> >(); gil_function_requires<MutableChannelConcept<DST_T> >(); dst=channel_convert<DST_T,SRC_T>(src); } SRC_T src; DST_T dst; }; template <typename P> struct HeterogeneousPixelConcept { void constraints() { typedef typename P::color_space_t CS; gil_function_requires<ColorSpaceTypeConcept<CS> >(); typedef typename P::template kth_channel_t<0>::type T0; typedef typename P::template kth_channel_t<CS::num_channels-1>::type TN; gil_function_requires< boost::EqualityComparableConcept<P> >(); // ==, != pixel.template semantic_channel<0>(); // TODO: Call the other accessors pixel.template semantic_channel<CS::num_channels-1>(); pixel.template channel<0>(); // functions that work for every pixel (no need to require them) // max_channel(p), min_channel(p), fill_channels(p,value), and all variations of for_each_channel() and transform_channels() } P pixel; }; namespace detail { template <typename P> // Preconditions: P Models HeterogeneousPixelConcept struct HeterogeneousPixelIsMutableConcept { void constraints() { pixel=pixel; pixel.template semantic_channel<0>()=pixel.template semantic_channel<0>(); pixel.template semantic_channel<P::color_space_t::num_channels-1>()=pixel.template semantic_channel<0>(); pixel.template channel<0>()=pixel.template channel<0>(); } P pixel; }; } template <typename P> struct MutableHeterogeneousPixelConcept { void constraints() { gil_function_requires< HeterogeneousPixelConcept<P> >(); gil_function_requires< detail::HeterogeneousPixelIsMutableConcept<P> >(); } }; template <typename P> struct HeterogeneousPixelValueConcept { void constraints() { gil_function_requires< HeterogeneousPixelConcept<P> >(); gil_function_requires< ValueType<P> >(); } }; template <typename P> struct MutableHeterogeneousPixelValueConcept { void constraints() { gil_function_requires< HeterogeneousPixelValueConcept<P> >(); gil_function_requires< detail::HeterogeneousPixelIsMutableConcept<P> >(); } }; template <typename P> struct PixelConcept { void constraints() { gil_function_requires<HeterogeneousPixelConcept<P> >(); typedef typename P::channel_t T; typedef typename P::channel_reference TR; typedef typename P::channel_const_reference CTR; gil_function_requires<ChannelValueConcept<T> >(); pixel[0]; // functions that work for every pixel (no need to require them) // max_channel(p), min_channel(p), fill_channels(p,value), and all variations of for_each_channel() and transform_channels() } P pixel; }; namespace detail { template <typename P> // Preconditions: P Models PixelConcept struct PixelIsMutableConcept { void constraints() { gil_function_requires< detail::HeterogeneousPixelIsMutableConcept<P> >(); pixel[0]=pixel[0]; } P pixel; }; } template <typename P> struct MutablePixelConcept { void constraints() { gil_function_requires< PixelConcept<P> >(); gil_function_requires< detail::PixelIsMutableConcept<P> >(); } }; template <typename P> struct PixelValueConcept { void constraints() { gil_function_requires< PixelConcept<P> >(); gil_function_requires< ValueType<P> >(); } }; template <typename P> struct MutablePixelValueConcept { void constraints() { gil_function_requires< PixelValueConcept<P> >(); gil_function_requires< detail::PixelIsMutableConcept<P> >(); } }; template <typename P1, typename P2> // Models GIL Pixel struct pixels_are_compatible : public boost::mpl::and_<color_spaces_are_compatible<typename P1::color_space_t, typename P2::color_space_t>, channels_are_compatible <typename P1::channel_t, typename P2::channel_t > >{}; template <typename P1, typename P2> struct PixelsCompatibleConcept { void constraints() { BOOST_STATIC_ASSERT((pixels_are_compatible<P1,P2>::value)); } }; template <typename SRC_P, typename DST_P> struct PixelConvertibleConcept { void constraints() { gil_function_requires<PixelConcept<SRC_P> >(); gil_function_requires<MutablePixelConcept<DST_P> >(); gil_function_requires<ChannelConvertibleConcept<typename SRC_P::channel_t, typename DST_P::channel_t> >(); color_convert(src,dst); } SRC_P src; DST_P dst; }; template <typename IT> struct PixelIteratorConcept { void constraints() { gil_function_requires<boost::RandomAccessIteratorConcept<IT> >(); typedef typename std::iterator_traits<IT>::value_type value_type; gil_function_requires<PixelValueConcept<value_type> >(); typedef typename pixel_iterator_traits<IT>::const_reference const_reference; // gil_function_requires<PixelConcept<const_reference> >(); typedef typename pixel_iterator_traits<IT>::channel_t channel_t; gil_function_requires<ChannelValueConcept<channel_t> >(); typedef typename pixel_iterator_traits<IT>::color_space_t color_space_t; gil_function_requires<ColorSpaceTypeConcept<color_space_t> >(); // We want to make sure DST Models StepIterator and ConstPixelIterator and CNT Models ConstPixelIterator, but wouldn't that cause infinite loop? typedef typename pixel_iterator_traits<IT>::dynamic_step_t dynamic_step_t; typedef typename pixel_iterator_traits<IT>::const_t const_t; const_t const_it(it); // immutable iterator must be constructible from (possibly mutable) iterator static const bool ib=pixel_iterator_traits<IT>::is_base; boost::ignore_unused_variable_warning(ib); static const bool ip=pixel_iterator_traits<IT>::is_planar; boost::ignore_unused_variable_warning(ip); static const bool pdi=pixel_iterator_traits<IT>::pixel_data_is_real; boost::ignore_unused_variable_warning(pdi); // when is_base is false, it must also have typename std::iterator_traits<IT>::base_t defined } IT it; }; namespace detail { template <typename IT> // Preconditions: IT Models PixelIteratorConcept struct PixelIteratorIsMutableConcept { void constraints() { gil_function_requires<detail::RandomAccessIteratorIsMutableConcept<IT> >(); gil_function_requires<detail::ChannelIsMutableConcept<typename pixel_iterator_traits<IT>::channel_t> >(); } }; } template <typename IT> struct MutablePixelIteratorConcept { void constraints() { gil_function_requires<PixelIteratorConcept<IT> >(); gil_function_requires<detail::PixelIteratorIsMutableConcept<IT> >(); } }; namespace detail { // Iterators that can be used as the base of pixel_step_iterator require some additional functions template <typename IT> // Preconditions: IT Models boost::RandomAccessIteratorConcept struct RandomAccessIteratorIsByteAdvancableConcept { void constraints() { std::ptrdiff_t bs=byte_step(it); boost::ignore_unused_variable_warning(bs); it=byte_advanced(it,3); std::ptrdiff_t bd=byte_distance(it,it); boost::ignore_unused_variable_warning(bd); byte_advance(it,3); // for performace you may also provide a customized implementation of byte_advanced_ref } IT it; }; } template <typename IT> struct ByteAdvancableIteratorConcept { void constraints() { gil_function_requires<boost::RandomAccessIteratorConcept<IT> >(); gil_function_requires<detail::RandomAccessIteratorIsByteAdvancableConcept<IT> >(); } }; template <typename IT> struct IteratorAdaptorConcept { void constraints() { gil_function_requires<boost::ForwardIteratorConcept<IT> >(); typedef typename pixel_iterator_traits<IT>::base_t base_t; gil_function_requires<boost::ForwardIteratorConcept<base_t> >(); BOOST_STATIC_ASSERT(!pixel_iterator_traits<IT>::is_base); base_t base=it.base(); boost::ignore_unused_variable_warning(base); } IT it; }; template <typename IT> struct StepIteratorConcept { void constraints() { gil_function_requires<boost::ForwardIteratorConcept<IT> >(); it.set_step(0); } IT it; }; template <typename IT> struct PixelIteratorAdaptorConcept; template <typename IT> struct PixelStepIteratorConcept { void constraints() { gil_function_requires<StepIteratorConcept<IT> >(); // In addition must be an iterator adaptor over pixels gil_function_requires<PixelIteratorAdaptorConcept<IT> >(); // Must be byte advanceable gil_function_requires<detail::RandomAccessIteratorIsByteAdvancableConcept<IT> >(); // Must be constructible from the base iterator and byte step typedef typename pixel_iterator_traits<IT>::base_t base_t; IT(base_t(), std::ptrdiff_t()); } }; template <typename IT> struct PixelIteratorAdaptorConcept { void constraints() { gil_function_requires<IteratorAdaptorConcept<IT> >(); gil_function_requires<PixelIteratorConcept<IT> >(); } }; template <typename IT> struct MutableIteratorAdaptorConcept { void constraints() { gil_function_requires<IteratorAdaptorConcept<IT> >(); gil_function_requires<detail::ForwardIteratorIsMutableConcept<IT> >(); } }; template <typename IT> struct MutablePixelIteratorAdaptorConcept { void constraints() { gil_function_requires<PixelIteratorAdaptorConcept<IT> >(); gil_function_requires<detail::PixelIteratorIsMutableConcept<IT> >(); } }; template <typename IT> struct MutableStepIteratorConcept { void constraints() { gil_function_requires<StepIteratorConcept<IT> >(); gil_function_requires<detail::ForwardIteratorIsMutableConcept<IT> >(); } }; template <typename IT> struct MutablePixelStepIteratorConcept { void constraints() { gil_function_requires<PixelStepIteratorConcept<IT> >(); gil_function_requires<detail::PixelIteratorIsMutableConcept<IT> >(); } }; template <typename IT> struct PixelImageIteratorConcept { void constraints() { gil_function_requires<PixelIteratorConcept<IT> >(); it.width(); it.x_pos(); bool is_contig=it.is_contiguous(); typedef typename IT::x_iterator x_iterator; x_iterator xit = it.x(); } IT it; }; template <typename IT> struct MutablePixelImageIteratorConcept { void constraints() { gil_function_requires<PixelImageIteratorConcept<IT> >(); gil_function_requires<detail::PixelIteratorIsMutableConcept<IT> >(); } }; template <typename LOC> struct RandomAccessNDLocatorConcept { void constraints() { gil_function_requires< ValueType<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::domain_t domain_t; // same as value_type typedef typename LOC::point_t point_t; // same as difference_type static const std::size_t N=LOC::num_dimensions; 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::RandomAccessIteratorConcept<first_it_type> >(); gil_function_requires<boost::RandomAccessIteratorConcept<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((boost::is_same<typename std::iterator_traits<first_it_type>::difference_type, typename point_t::template axis<0>::coord_t>::value)); BOOST_STATIC_ASSERT((boost::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]; boost::ignore_unused_variable_warning(r1); reference r2=*loc; boost::ignore_unused_variable_warning(r2); cached_location_t cl=loc.cache_location(d); boost::ignore_unused_variable_warning(cl); reference r3=loc[d]; boost::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); } LOC loc; }; template <typename LOC> struct RandomAccess2DLocatorConcept { void constraints() { gil_function_requires<RandomAccessNDLocatorConcept<LOC> >(); BOOST_STATIC_ASSERT(LOC::num_dimensions==2); 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; y_coord_t yd; typename LOC::difference_type d; typename LOC::reference r=loc(xd,yd); boost::ignore_unused_variable_warning(r); 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); } 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::dynamic_step_t dynamic_step_t; typedef typename LOC::channel_t channel_t; typedef typename LOC::color_space_t color_space_t; typedef typename LOC::coord_t coord_t; typedef typename LOC::pixel_t pixel_t; BOOST_STATIC_ASSERT((boost::is_same<typename LOC::x_coord_t, typename LOC::y_coord_t>::value)); BOOST_STATIC_ASSERT(LOC::num_channels == color_space_t::num_channels); typename LOC::x_iterator xit; std::ptrdiff_t row_bytes; LOC lc(xit, row_bytes); std::ptrdiff_t r=loc.row_bytes(); r=loc.pix_bytestep(); } 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; typename LOC::value_type 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; typename LOC::y_coord_t yd; typename LOC::value_type 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< ValueType<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::domain_t domain_t; // same as value_type 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::RandomAccessIteratorConcept<iterator> >(); gil_function_requires<boost::RandomAccessIteratorConcept<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::RandomAccessIteratorConcept<first_it_type> >(); gil_function_requires<boost::RandomAccessIteratorConcept<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((boost::is_same<typename std::iterator_traits<first_it_type>::difference_type, typename point_t::template axis<0>::coord_t>::value)); BOOST_STATIC_ASSERT((boost::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; VIEW(p,lc); // view must be constructible from a locator and a point p=view.dimensions(); lc=view.pixels(); size_type sz=view.size(); boost::ignore_unused_variable_warning(sz); it=view.begin(); it=view.end(); rit=view.rbegin(); rit=view.rend(); reference r1=view[d]; boost::ignore_unused_variable_warning(r1); // 1D access reference r2=view(p); boost::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); boost::ignore_unused_variable_warning(fi); last_it_type li=view.template axis_iterator<N-1>(p); } 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 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; y_coord_t 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); boost::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((boost::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) typedef typename VIEW::dynamic_step_t dynamic_step_t; typedef typename VIEW::channel_t channel_t; typedef typename VIEW::color_space_t color_space_t; typedef typename VIEW::pixel_t pixel_t; BOOST_STATIC_ASSERT(VIEW::num_channels == color_space_t::num_channels); typename VIEW::x_iterator xit; typename VIEW::difference_type diff; typename VIEW::point_t pt; VIEW(pt, xit, diff); VIEW(pt.x, pt.y, xit, diff); diff=view.row_bytes(); diff=view.pix_bytestep(); } 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; typename VIEW::point_t pt; typename VIEW::value_type 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; typename VIEW::y_coord_t yd; typename VIEW::value_type 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::pixel_t, typename V2::pixel_t> {}; 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<boost::RandomAccessContainerConcept<IMG> >(); gil_function_requires<boost::DefaultConstructibleConcept<IMG> >(); typedef typename IMG::view_t view_t; typedef typename IMG::const_view_t const_view_t; gil_function_requires<MutableRandomAccessNDImageViewConcept<view_t> >(); const_view_t cv=const_view(img); typedef typename IMG::point_t point_t; gil_function_requires<PointNDConcept<point_t> >(); point_t pt=img.dimensions(); IMG(pt,1); // construct with dimensions and alignment } 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; x_coord_t w=img.width(); y_coord_t h=img.height(); IMG(w,h,1); // construct with width, height and alignment } 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(IMG::num_channels == IMG::color_space_t::num_channels); BOOST_STATIC_ASSERT((boost::is_same<coord_t, typename IMG::x_coord_t>::value)); BOOST_STATIC_ASSERT((boost::is_same<coord_t, typename IMG::y_coord_t>::value)); } IMG img; }; #ifdef _MSC_VER #pragma warning(pop) #endif ADOBE_GIL_NAMESPACE_END #endif

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

Copyright © 2006 Adobe Systems Incorporated.

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

Search powered by Google