core/algorithm.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_ALGORITHM_HPP #define GIL_ALGORITHM_HPP #include <cassert> #include <cstddef> #include <algorithm> #include "gil_config.hpp" #include "gil_concept.hpp" #include "pixel_algorithm.hpp" #include "image_view.hpp" #include "image_view_factory.hpp" ADOBE_GIL_NAMESPACE_BEGIN // a tag denoting incompatible arguments struct error_t {}; template <typename Derived, typename Result=void> struct binary_operation_obj { typedef Result result_type; template <typename V1, typename V2> GIL_FORCEINLINE result_type operator()(const std::pair<const V1*,const V2*>& p) const { return apply(*p.first, *p.second, typename views_are_compatible<V1,V2>::type()); } template <typename V1, typename V2> GIL_FORCEINLINE result_type operator()(const V1& v1, const V2& v2) const { return apply(v1, v2, typename views_are_compatible<V1,V2>::type()); } result_type operator()(const error_t&) const { throw std::bad_cast(); } private: // dispatch from apply overload to a function with distinct name template <typename V1, typename V2> GIL_FORCEINLINE result_type apply(const V1& v1, const V2& v2, boost::mpl::false_) const { return ((const Derived*)this)->apply_incompatible(v1,v2); } // dispatch from apply overload to a function with distinct name template <typename V1, typename V2> GIL_FORCEINLINE result_type apply(const V1& v1, const V2& v2, boost::mpl::true_) const { return ((const Derived*)this)->apply_compatible(v1,v2); } // function with distinct name - it can be overloaded by subclasses template <typename V1, typename V2> GIL_FORCEINLINE result_type apply_incompatible(const V1& v1, const V2& v2) const { throw std::bad_cast(); } }; ADOBE_GIL_NAMESPACE_END namespace std { template<typename T, typename Cs> GIL_FORCEINLINE GIL::pixel<T,Cs>* copy(GIL::pixel<T,Cs>* first, GIL::pixel<T,Cs>* last, GIL::pixel<T,Cs>* dst) { return (GIL::pixel<T,Cs>*)std::copy((unsigned char*)first,(unsigned char*)last, (unsigned char*)dst); } template<typename T, typename Cs> GIL_FORCEINLINE GIL::pixel<T,Cs>* copy(const GIL::pixel<T,Cs>* first, const GIL::pixel<T,Cs>* last, GIL::pixel<T,Cs>* dst) { return (GIL::pixel<T,Cs>*)std::copy((unsigned char*)first,(unsigned char*)last, (unsigned char*)dst); } } ADOBE_GIL_NAMESPACE_BEGIN namespace detail { template <typename I, typename O> struct copy_fn { GIL_FORCEINLINE I operator()(I first, I last, O dst) const { return std::copy(first,last,dst); } }; } ADOBE_GIL_NAMESPACE_END namespace std { template<typename IC1, typename Cs1, typename IC2, typename Cs2> GIL_FORCEINLINE GIL::planar_ptr<IC2,Cs2> copy(GIL::planar_ptr<IC1,Cs1> first, GIL::planar_ptr<IC1,Cs1> last, GIL::planar_ptr<IC2,Cs2> dst) { GIL::gil_function_requires<GIL::ChannelsCompatibleConcept<typename std::iterator_traits<IC1>::value_type,typename std::iterator_traits<IC2>::value_type> >(); GIL::gil_function_requires<GIL::ColorSpacesCompatibleConcept<Cs1,Cs2> >(); for_each_channel(first,last,dst,GIL::detail::copy_fn<IC1,IC2>()); return dst+(last-first); } } ADOBE_GIL_NAMESPACE_BEGIN namespace detail { template <typename I, typename O> struct copier_n { GIL_FORCEINLINE void operator()(I src, typename std::iterator_traits<I>::difference_type n, O dst) const { std::copy(src,src+n, dst); } }; template <typename IL, typename O> // IL Models ConstPixelLocatorConcept, O Models PixelIteratorConcept struct copier_n<GIL::pixel_image_iterator<IL>,O> { typedef typename std::iterator_traits<GIL::pixel_image_iterator<IL> >::difference_type diff_t; GIL_FORCEINLINE void operator()(GIL::pixel_image_iterator<IL> src, diff_t n, O dst) const { GIL::gil_function_requires<GIL::PixelLocatorConcept<IL> >(); GIL::gil_function_requires<GIL::MutablePixelIteratorConcept<O> >(); while (n>0) { typedef typename GIL::pixel_image_iterator<IL>::difference_type diff_t; diff_t l=src.width()-src.x_pos(); diff_t numToCopy=(n<l ? n:l); adobe::copy_n(src.x(), numToCopy, dst); dst+=numToCopy; src+=numToCopy; n-=numToCopy; } } }; template <typename I, typename OL> // I Models ConstPixelIteratorConcept, OL Models PixelLocatorConcept struct copier_n<I,GIL::pixel_image_iterator<OL> > { typedef typename std::iterator_traits<I>::difference_type diff_t; GIL_FORCEINLINE void operator()(I src, diff_t n, GIL::pixel_image_iterator<OL> dst) const { GIL::gil_function_requires<GIL::PixelIteratorConcept<I> >(); GIL::gil_function_requires<GIL::MutablePixelLocatorConcept<OL> >(); while (n>0) { diff_t l=dst.width()-dst.x_pos(); diff_t numToCopy=(n<l ? n:l); adobe::copy_n(src, numToCopy, dst.x()); dst+=numToCopy; src+=numToCopy; n-=numToCopy; } } }; template <typename IL, typename OL> struct copier_n<GIL::pixel_image_iterator<IL>,GIL::pixel_image_iterator<OL> > { typedef typename GIL::pixel_image_iterator<IL>::difference_type diff_t; GIL_FORCEINLINE void operator()(GIL::pixel_image_iterator<IL> src, diff_t n, GIL::pixel_image_iterator<OL> dst) const { GIL::gil_function_requires<GIL::PixelLocatorConcept<IL> >(); GIL::gil_function_requires<GIL::MutablePixelLocatorConcept<OL> >(); if (src.x_pos()!=dst.x_pos() || src.width()!=dst.width()) { while(n-->0) { *dst++=*src++; } } while (n>0) { diff_t l=dst.width()-dst.x_pos(); diff_t numToCopy=(n<l ? n : l); adobe::copy_n(src.x(), numToCopy, dst.x()); dst+=numToCopy; src+=numToCopy; n-=numToCopy; } } }; } ADOBE_GIL_NAMESPACE_END namespace std { template <typename IL, typename OL> GIL_FORCEINLINE GIL::pixel_image_iterator<OL> copy(GIL::pixel_image_iterator<IL> first, GIL::pixel_image_iterator<IL> last, GIL::pixel_image_iterator<OL> dst) { GIL::gil_function_requires<GIL::PixelLocatorConcept<IL> >(); GIL::gil_function_requires<GIL::MutablePixelLocatorConcept<OL> >(); typedef typename GIL::pixel_image_iterator<IL>::difference_type diff_t; diff_t n=diff_t(last-first); if (first.is_contiguous()) { if (dst.is_contiguous()) GIL::detail::copier_n<typename IL::x_iterator,typename OL::x_iterator>()(first.x(),n, dst.x()); else GIL::detail::copier_n<typename IL::x_iterator,GIL::pixel_image_iterator<OL> >()(first.x(),n, dst); } else { if (dst.is_contiguous()) GIL::detail::copier_n<GIL::pixel_image_iterator<IL>,typename OL::x_iterator>()(first,n, dst.x()); else GIL::detail::copier_n<GIL::pixel_image_iterator<IL>,GIL::pixel_image_iterator<OL> >()(first,n,dst); } return dst+n; } } ADOBE_GIL_NAMESPACE_BEGIN template <typename V1, typename V2> GIL_FORCEINLINE void copy_pixels(const V1& src, const V2& dst) { assert(src.dimensions()==dst.dimensions()); std::copy(src.begin(),src.end(),dst.begin()); // std::copy will choose the optimal method (see stl_override.h) } namespace detail { template <typename CC> class copy_and_convert_pixels_fn : public binary_operation_obj<copy_and_convert_pixels_fn<CC> > { private: CC _cc; public: typedef typename binary_operation_obj<copy_and_convert_pixels_fn<CC> >::result_type result_type; copy_and_convert_pixels_fn() {} copy_and_convert_pixels_fn(CC cc_in) : _cc(cc_in) {} // when the two color spaces are incompatible, a color conversion is performed template <typename V1, typename V2> GIL_FORCEINLINE result_type apply_incompatible(const V1& src, const V2& dst) const { copy_pixels(color_converted_view<typename V2::value_type>(src,_cc),dst); } // If the two color spaces are compatible, copy_and_convert is just copy template <typename V1, typename V2> GIL_FORCEINLINE result_type apply_compatible(const V1& src, const V2& dst) const { copy_pixels(src,dst); } }; } template <typename V1, typename V2,typename CC> GIL_FORCEINLINE void copy_and_convert_pixels(const V1& src, const V2& dst,CC cc) { detail::copy_and_convert_pixels_fn<CC> ccp(cc); ccp(src,dst); } //forward declaration for default_color_converter (see full definition in color_convert.hpp) struct default_color_converter; template <typename V1, typename V2> GIL_FORCEINLINE void copy_and_convert_pixels(const V1& src, const V2& dst) { detail::copy_and_convert_pixels_fn<default_color_converter> ccp; ccp(src,dst); } ADOBE_GIL_NAMESPACE_END // // std::fill and gil::fill_pixels // namespace std { template <typename IL, typename V> void fill(GIL::pixel_image_iterator<IL> first, GIL::pixel_image_iterator<IL> last, const V& val) { GIL::gil_function_requires<GIL::MutablePixelLocatorConcept<IL> >(); if (first.is_contiguous()) { std::fill(first.x(), last.x(), val); } else { // fill row by row std::ptrdiff_t n=last-first; while (n>0) { std::ptrdiff_t numToDo=std::min<const std::ptrdiff_t>(n,(std::ptrdiff_t)(first.width()-first.x_pos())); fill_n(first.x(), numToDo, val); first+=numToDo; n-=numToDo; } } } } ADOBE_GIL_NAMESPACE_BEGIN template <typename V, typename Value> GIL_FORCEINLINE void fill_pixels(const V& img_view, const Value& val) { if (img_view.begin().is_contiguous()) { std::fill(img_view.begin().x(), img_view.end().x(), val); } else { for (int y=0; y<img_view.height(); ++y) std::fill(img_view.row_begin(y),img_view.row_end(y),val); } } ADOBE_GIL_NAMESPACE_END ADOBE_GIL_NAMESPACE_BEGIN template <typename V, typename F> F for_each_pixel(const V& img, F fun) { if (img.begin().is_contiguous()) { return std::for_each(img.begin().x(), img.end().x(), fun); } else { for (int y=0; y<img.height(); ++y) fun = std::for_each(img.row_begin(y),img.row_end(y),fun); return fun; } } template <typename View, typename F> F for_each_pixel_position(const View& img, F fun) { typename View::xy_locator loc=img.xy_at(0,0); for (int y=0; y<img.height(); ++y) { for (int x=0; x<img.width(); ++x, ++loc.x()) fun(loc); loc.x()-=img.width(); ++loc.y(); } return fun; } ADOBE_GIL_NAMESPACE_END ADOBE_GIL_NAMESPACE_BEGIN template <typename V, typename F> F generate_pixels(const V& img, F fun) { if (img.begin().is_contiguous()) return std::generate(img.begin().x(), img.end().x(), fun); else { for (int y=0; y<img.height(); ++y) fun = std::generate(img.row_begin(y),img.row_end(y),fun); return fun; } } ADOBE_GIL_NAMESPACE_END ADOBE_GIL_NAMESPACE_BEGIN template <typename I1, typename I2> GIL_FORCEINLINE bool equal_n(I1 i1, std::ptrdiff_t n, I2 i2); namespace detail { template <typename I1, typename I2> struct equal_n_fn { GIL_FORCEINLINE bool operator()(I1 i1, std::ptrdiff_t n, I2 i2) const { return std::equal(i1,i1+n, i2); } }; template<typename T, typename Cs> struct equal_n_fn<const pixel<T,Cs>*, const pixel<T,Cs>*> { GIL_FORCEINLINE bool operator()(const pixel<T,Cs>* i1, std::ptrdiff_t n, const pixel<T,Cs>* i2) const { return memcmp(i1, i2, n*sizeof(pixel<T,Cs>))==0; } }; template<typename T, typename Cs> struct equal_n_fn<pixel<T,Cs>*, pixel<T,Cs>*> : equal_n_fn<const pixel<T,Cs>*, const pixel<T,Cs>*> {}; template<typename IC, typename Cs> struct equal_n_fn<planar_ptr<IC,Cs>, planar_ptr<IC,Cs> > { GIL_FORCEINLINE bool operator()(const planar_ptr<IC,Cs> i1, std::ptrdiff_t n, const planar_ptr<IC,Cs> i2) const { ptrdiff_t numBytes=n*sizeof(typename std::iterator_traits<IC>::value_type); for (int i=0; i<Cs::num_channels; ++i) if (memcmp(i1.channel_ptr(i), i2.channel_ptr(i), numBytes)!=0) return false; return true; } }; template <typename Loc, typename I2> // IL Models ConstPixelLocatorConcept, O Models PixelIteratorConcept struct equal_n_fn<GIL::pixel_image_iterator<Loc>,I2> { GIL_FORCEINLINE bool operator()(GIL::pixel_image_iterator<Loc> i1, std::ptrdiff_t n, I2 i2) const { GIL::gil_function_requires<GIL::PixelLocatorConcept<Loc> >(); GIL::gil_function_requires<GIL::PixelIteratorConcept<I2> >(); while (n>0) { std::ptrdiff_t num=std::min<const std::ptrdiff_t>(n, i1.width()-i1.x_pos()); if (!equal_n(i1.x(), num, i2)) return false; i1+=num; i2+=num; n-=num; } return true; } }; template <typename I1, typename Loc> // I Models PixelIteratorConcept, OL Models PixelLocatorConcept struct equal_n_fn<I1,GIL::pixel_image_iterator<Loc> > { GIL_FORCEINLINE bool operator()(I1 i1, std::ptrdiff_t n, GIL::pixel_image_iterator<Loc> i2) const { GIL::gil_function_requires<GIL::PixelIteratorConcept<I1> >(); GIL::gil_function_requires<GIL::PixelLocatorConcept<Loc> >(); while (n>0) { std::ptrdiff_t num=std::min<const std::ptrdiff_t>(n,i2.width()-i2.x_pos()); if (!equal_n(i1, num, i2.x())) return false; i1+=num; i2+=num; n-=num; } return true; } }; template <typename Loc1, typename Loc2> struct equal_n_fn<GIL::pixel_image_iterator<Loc1>,GIL::pixel_image_iterator<Loc2> > { GIL_FORCEINLINE bool operator()(GIL::pixel_image_iterator<Loc1> i1, std::ptrdiff_t n, GIL::pixel_image_iterator<Loc2> i2) const { GIL::gil_function_requires<GIL::PixelLocatorConcept<Loc1> >(); GIL::gil_function_requires<GIL::PixelLocatorConcept<Loc2> >(); if (i1.x_pos()!=i2.x_pos() || i1.width()!=i2.width()) { while(n-->0) { if (*i1++!=*i2++) return false; } } while (n>0) { std::ptrdiff_t num=std::min<const std::ptrdiff_t>(n,i2.width()-i2.x_pos()); if (!equal_n(i1.x(), num, i2.x())) return false; i1+=num; i2+=num; n-=num; } return true; } }; } template <typename I1, typename I2> GIL_FORCEINLINE bool equal_n(I1 i1, std::ptrdiff_t n, I2 i2) { return detail::equal_n_fn<I1,I2>()(i1,n,i2); } ADOBE_GIL_NAMESPACE_END namespace std { template <typename Loc1, typename Loc2> GIL_FORCEINLINE bool equal(GIL::pixel_image_iterator<Loc1> first, GIL::pixel_image_iterator<Loc1> last, GIL::pixel_image_iterator<Loc2> first2) { GIL::gil_function_requires<GIL::PixelLocatorConcept<Loc1> >(); GIL::gil_function_requires<GIL::PixelLocatorConcept<Loc2> >(); std::ptrdiff_t n=last-first; if (first.is_contiguous()) { if (first2.is_contiguous()) return GIL::detail::equal_n_fn<typename Loc1::x_iterator,typename Loc2::x_iterator>()(first.x(),n, first2.x()); else return GIL::detail::equal_n_fn<typename Loc1::x_iterator,GIL::pixel_image_iterator<Loc2> >()(first.x(),n, first2); } else { if (first2.is_contiguous()) return GIL::detail::equal_n_fn<GIL::pixel_image_iterator<Loc1>,typename Loc2::x_iterator>()(first,n, first2.x()); else return GIL::detail::equal_n_fn<GIL::pixel_image_iterator<Loc1>,GIL::pixel_image_iterator<Loc2> >()(first,n,first2); } } } ADOBE_GIL_NAMESPACE_BEGIN namespace detail { struct equal_pixels_fn : public binary_operation_obj<equal_pixels_fn,bool> { template <typename V1, typename V2> GIL_FORCEINLINE bool operator()(const V1& v1, const V2& v2) const { assert(v1.dimensions()==v2.dimensions()); return std::equal(v1.begin(),v1.end(),v2.begin()); // std::equal has overloads with GIL iterators for optimal performance } }; } template <typename V1, typename V2> GIL_FORCEINLINE bool equal_pixels(const V1& v1, const V2& v2) { return detail::equal_pixels_fn()(v1,v2); } ADOBE_GIL_NAMESPACE_END ADOBE_GIL_NAMESPACE_BEGIN template <typename V1, typename V2, typename F> GIL_FORCEINLINE F transform_pixels(const V1& src,const V2& dst, F fun) { assert(src.dimensions()==dst.dimensions()); for (int y=0; y<src.height(); ++y) { typename V1::x_iterator srcIt=src.row_begin(y); typename V2::x_iterator dstIt=dst.row_begin(y); for (int x=0; x<src.width(); ++x) dstIt[x]=fun(srcIt[x]); } return fun; } template <typename V1, typename V2, typename V3, typename F> GIL_FORCEINLINE F transform_pixels(const V1& src1, const V2& src2,const V3& dst, F fun) { for (int y=0; y<dst.height(); ++y) { typename V1::x_iterator srcIt1=src1.row_begin(y); typename V2::x_iterator srcIt2=src2.row_begin(y); typename V3::x_iterator dstIt=dst.row_begin(y); for (int x=0; x<dst.width(); ++x) dstIt[x]=fun(srcIt1[x],srcIt2[x]); } return fun; } template <typename V1, typename V2, typename F> GIL_FORCEINLINE F transform_pixel_positions(const V1& src,const V2& dst, F fun) { assert(src.dimensions()==dst.dimensions()); typename V1::xy_locator loc=src.xy_at(0,0); for (int y=0; y<src.height(); ++y) { typename V2::x_iterator dstIt=dst.row_begin(y); for (int x=0; x<src.width(); ++x, ++loc.x()) dstIt[x]=fun(loc); loc.x()-=src.width(); ++loc.y(); } return fun; } template <typename V1, typename V2, typename V3, typename F> GIL_FORCEINLINE F transform_pixel_positions(const V1& src1,const V2& src2,const V3& dst, F fun) { assert(src1.dimensions()==dst.dimensions()); assert(src2.dimensions()==dst.dimensions()); typename V1::xy_locator loc1=src1.xy_at(0,0); typename V2::xy_locator loc2=src2.xy_at(0,0); for (int y=0; y<src1.height(); ++y) { typename V3::x_iterator dstIt=dst.row_begin(y); for (int x=0; x<src1.width(); ++x, ++loc1.x(), ++loc2.x()) dstIt[x]=fun(loc1,loc2); loc1.x()-=src1.width(); ++loc1.y(); loc2.x()-=src2.width(); ++loc2.y(); } return fun; } 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