algorithm.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_ALGORITHM_HPP
#define GIL_ALGORITHM_HPP

#include <cassert>
#include <cstddef>
#include <cstring>
#include <algorithm>
#include <iterator>
#include <memory>
#include <typeinfo>
#include "gil_config.hpp"
#include "gil_concept.hpp"
#include "color_base_algorithm.hpp"
#include "image_view.hpp"
#include "image_view_factory.hpp"
#include "bit_aligned_pixel_iterator.hpp"


//#ifdef _MSC_VER
//#pragma warning(push)
//#pragma warning(disable : 4244)     // conversion from 'gil::image<V,Alloc>::coord_t' to 'int', possible loss of data (visual studio compiler doesn't realize that the two types are the same)
//#endif

namespace boost { namespace gil {

//forward declarations
template <typename ChannelPtr, typename ColorSpace>
struct planar_pixel_iterator;
template <typename Iterator>
class memory_based_step_iterator;
template <typename StepIterator>
class memory_based_2d_locator;

// 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, 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, 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();
    }
};
} }  // namespace boost::gil



namespace std {

template<typename T, typename Cs> 
GIL_FORCEINLINE boost::gil::pixel<T,Cs>* 
copy(boost::gil::pixel<T,Cs>* first, boost::gil::pixel<T,Cs>* last, 
     boost::gil::pixel<T,Cs>* dst) { 
    return (boost::gil::pixel<T,Cs>*)std::copy((unsigned char*)first,(unsigned char*)last, (unsigned char*)dst);
}

template<typename T, typename Cs> 
GIL_FORCEINLINE boost::gil::pixel<T,Cs>* 
copy(const boost::gil::pixel<T,Cs>* first, const boost::gil::pixel<T,Cs>* last, 
     boost::gil::pixel<T,Cs>* dst) { 
    return (boost::gil::pixel<T,Cs>*)std::copy((unsigned char*)first,(unsigned char*)last, (unsigned char*)dst);
}
} // namespace std

namespace boost { namespace gil {
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); } 
};
} // namespace detail
} }  // namespace boost::gil

namespace std {
template<typename Cs, typename IC1, typename IC2> GIL_FORCEINLINE
boost::gil::planar_pixel_iterator<IC2,Cs> copy(boost::gil::planar_pixel_iterator<IC1,Cs> first, boost::gil::planar_pixel_iterator<IC1,Cs> last, boost::gil::planar_pixel_iterator<IC2,Cs> dst) { 
    boost::gil::gil_function_requires<boost::gil::ChannelsCompatibleConcept<typename std::iterator_traits<IC1>::value_type,typename std::iterator_traits<IC2>::value_type> >();
    static_for_each(first,last,dst,boost::gil::detail::copy_fn<IC1,IC2>());
    return dst+(last-first);
}
} // namespace std

namespace boost { namespace gil {
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<iterator_from_2d<IL>,O> {
    typedef typename std::iterator_traits<iterator_from_2d<IL> >::difference_type diff_t;
    GIL_FORCEINLINE void operator()(iterator_from_2d<IL> src, diff_t n, O dst) const {
        gil_function_requires<PixelLocatorConcept<IL> >();
        gil_function_requires<MutablePixelIteratorConcept<O> >();
        while (n>0) {
            typedef typename iterator_from_2d<IL>::difference_type diff_t;
            diff_t l=src.width()-src.x_pos();
            diff_t numToCopy=(n<l ? n:l);
            detail::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,iterator_from_2d<OL> > {
    typedef typename std::iterator_traits<I>::difference_type diff_t;
    GIL_FORCEINLINE void operator()(I src, diff_t n, iterator_from_2d<OL> dst) const {
        gil_function_requires<PixelIteratorConcept<I> >();
        gil_function_requires<MutablePixelLocatorConcept<OL> >();
        while (n>0) {
            diff_t l=dst.width()-dst.x_pos();
            diff_t numToCopy=(n<l ? n:l);
            detail::copy_n(src, numToCopy, dst.x());
            dst+=numToCopy;
            src+=numToCopy;
            n-=numToCopy;
        }
    }
};

template <typename IL, typename OL>
struct copier_n<iterator_from_2d<IL>,iterator_from_2d<OL> > {
   typedef typename iterator_from_2d<IL>::difference_type diff_t;
   GIL_FORCEINLINE void operator()(iterator_from_2d<IL> src, diff_t n, iterator_from_2d<OL> dst) const {
        gil_function_requires<PixelLocatorConcept<IL> >();
        gil_function_requires<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);
            detail::copy_n(src.x(), numToCopy, dst.x());
            dst+=numToCopy;
            src+=numToCopy;
            n-=numToCopy;
        }
    }
};

template <typename SrcIterator, typename DstIterator>
GIL_FORCEINLINE DstIterator copy_with_2d_iterators(SrcIterator first, SrcIterator last, DstIterator dst) {
    typedef typename SrcIterator::x_iterator src_x_iterator;
    typedef typename DstIterator::x_iterator dst_x_iterator;

    typename SrcIterator::difference_type n = last - first;

    if (first.is_1d_traversable()) {
        if (dst.is_1d_traversable())
            copier_n<src_x_iterator,dst_x_iterator>()(first.x(),n, dst.x());
        else
            copier_n<src_x_iterator,DstIterator >()(first.x(),n, dst);
    } else {
        if (dst.is_1d_traversable())
            copier_n<SrcIterator,dst_x_iterator>()(first,n, dst.x());
        else
            copier_n<SrcIterator,DstIterator>()(first,n,dst);
    }
    return dst+n;
}

} // namespace detail
} }  // namespace boost::gil

namespace std {
template <typename IL, typename OL>
GIL_FORCEINLINE boost::gil::iterator_from_2d<OL> copy1(boost::gil::iterator_from_2d<IL> first, boost::gil::iterator_from_2d<IL> last, boost::gil::iterator_from_2d<OL> dst) {
    return boost::gil::detail::copy_with_2d_iterators(first,last,dst);
}

} // namespace std

namespace boost { namespace gil {


template <typename View1, typename View2> GIL_FORCEINLINE
void copy_pixels(const View1& src, const View2& dst) { 
    assert(src.dimensions()==dst.dimensions());
    detail::copy_with_2d_iterators(src.begin(),src.end(),dst.begin());
}



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);
    }
};
} // namespace detail

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);
}

struct default_color_converter;

template <typename View1, typename View2> 
GIL_FORCEINLINE 
void copy_and_convert_pixels(const View1& src, const View2& dst) { 
    detail::copy_and_convert_pixels_fn<default_color_converter> ccp;
    ccp(src,dst);
}

} }  // namespace boost::gil

//
// std::fill and gil::fill_pixels
//



namespace std {
template <typename IL, typename V>
void fill(boost::gil::iterator_from_2d<IL> first, boost::gil::iterator_from_2d<IL> last, const V& val) {
    boost::gil::gil_function_requires<boost::gil::MutablePixelLocatorConcept<IL> >();
    if (first.is_1d_traversable()) {
        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;
        }
    }
} 
} // namespace std

namespace boost { namespace gil {

namespace detail {
struct std_fill_t {
    template <typename It, typename P>
    void operator()(It first, It last, const P& p_in) {
        std::fill(first,last,p_in);
    }
};
template <typename It, typename P>
GIL_FORCEINLINE 
void fill_aux(It first, It last, const P& p, mpl::true_) {
    static_for_each(first,last,p,std_fill_t());
}
template <typename It, typename P>
GIL_FORCEINLINE 
void fill_aux(It first, It last, const P& p,mpl::false_) {
    std::fill(first,last,p);
}
} // namespace detail

template <typename View, typename Value> GIL_FORCEINLINE 
void fill_pixels(const View& img_view, const Value& val) {
    if (img_view.is_1d_traversable())
        detail::fill_aux(img_view.begin().x(), img_view.end().x(), 
                 val,is_planar<View>());
    else
        for (std::ptrdiff_t y=0; y<img_view.height(); ++y)
            detail::fill_aux(img_view.row_begin(y),img_view.row_end(y),
                     val,is_planar<View>());
}




namespace detail {

template <typename It> GIL_FORCEINLINE
void destruct_range_impl(It first, It last, mpl::true_) {
    typedef typename std::iterator_traits<It>::value_type value_t;
    if (boost::has_trivial_destructor<value_t>::value)
        return;
    while (first!=last) {
        first->~value_t();
        ++first;
    }
}
template <typename It> GIL_FORCEINLINE
void destruct_range_impl(It first, It last, mpl::false_) {}

template <typename It> GIL_FORCEINLINE
void destruct_range(It first, It last) {
    destruct_range_impl(first,last,typename is_pointer<It>::type());
}

struct std_destruct_t {
    template <typename It> void operator()(It first, It last) const { destruct_range(first,last); }
};

template <typename It>
GIL_FORCEINLINE 
void destruct_aux(It first, It last, mpl::true_) {
    static_for_each(first,last,std_destruct_t());
}
template <typename It>
GIL_FORCEINLINE 
void destruct_aux(It first, It last, mpl::false_) {
    destruct_range(first,last);
}

} // namespace detail

template <typename View> GIL_FORCEINLINE 
void destruct_pixels(const View& img_view) {
    if (img_view.is_1d_traversable()) 
        detail::destruct_aux(img_view.begin().x(), img_view.end().x(), 
                                       is_planar<View>());
    else
        for (std::ptrdiff_t y=0; y<img_view.height(); ++y)
            detail::destruct_aux(img_view.row_begin(y),img_view.row_end(y),
                                           is_planar<View>());
}




namespace detail {

template <typename It, typename P>
GIL_FORCEINLINE 
void uninitialized_fill_aux(It first, It last,
                            const P& p, mpl::true_) {
    int channel=0;
    try {
        typedef typename std::iterator_traits<It>::value_type pixel_t;
        while (channel < num_channels<pixel_t>::value) {
            std::uninitialized_fill(dynamic_at_c(first,channel), dynamic_at_c(last,channel), 
                                    dynamic_at_c(p,channel));
            ++channel;
        }
    } catch (...) {
        for (int c=0; c<channel; ++c)
            destruct_range(dynamic_at_c(first,c), dynamic_at_c(last,c));
        throw;
    }
}

template <typename It, typename P>
GIL_FORCEINLINE 
void uninitialized_fill_aux(It first, It last,
                            const P& p,mpl::false_) {
    std::uninitialized_fill(first,last,p);
}

} // namespace detail

template <typename View, typename Value> 
void uninitialized_fill_pixels(const View& img_view, const Value& val) {
    if (img_view.is_1d_traversable()) 
        detail::uninitialized_fill_aux(img_view.begin().x(), img_view.end().x(), 
                                       val,is_planar<View>());
    else {
        typename View::y_coord_t y;
        try {
            for (y=0; y<img_view.height(); ++y)
                detail::uninitialized_fill_aux(img_view.row_begin(y),img_view.row_end(y),
                                               val,is_planar<View>());
        } catch(...) {
            for (typename View::y_coord_t y0=0; y0<y; ++y0)
                detail::destruct_aux(img_view.row_begin(y0),img_view.row_end(y0), is_planar<View>());
            throw;
        }
    }
}



namespace detail {

template <typename It> GIL_FORCEINLINE 
void default_construct_range_impl(It first, It last, mpl::true_) {
    typedef typename std::iterator_traits<It>::value_type value_t;
    It first1=first;
    try {
        while (first!=last) {
            new (first) value_t();
            ++first;
        }
    } catch (...) {
        destruct_range(first1,first);
        throw;
    }
}

template <typename It> GIL_FORCEINLINE 
void default_construct_range_impl(It first, It last, mpl::false_) {}

template <typename It> GIL_FORCEINLINE 
void default_construct_range(It first, It last) { default_construct_range_impl(first, last, typename is_pointer<It>::type()); }

template <typename It>
GIL_FORCEINLINE 
void default_construct_aux(It first, It last, mpl::true_) {
    int channel=0;
    try {
        typedef typename std::iterator_traits<It>::value_type pixel_t;
        while (channel < num_channels<pixel_t>::value) {
            default_construct_range(dynamic_at_c(first,channel), dynamic_at_c(last,channel));
            ++channel;
        }
    } catch (...) {
        for (int c=0; c<channel; ++c)
            destruct_range(dynamic_at_c(first,c), dynamic_at_c(last,c));
        throw;
    }
}

template <typename It>
GIL_FORCEINLINE 
void default_construct_aux(It first, It last, mpl::false_) {
    default_construct_range(first,last);
}

template <typename View, bool IsPlanar>
struct has_trivial_pixel_constructor : public boost::has_trivial_constructor<typename View::value_type> {};
template <typename View>
struct has_trivial_pixel_constructor<View, true> : public boost::has_trivial_constructor<typename channel_type<View>::type> {};

} // namespace detail

template <typename View> 
void default_construct_pixels(const View& img_view) {
    if (detail::has_trivial_pixel_constructor<View, is_planar<View>::value>::value)
        return;

    if (img_view.is_1d_traversable()) 
        detail::default_construct_aux(img_view.begin().x(), img_view.end().x(), is_planar<View>());
    else {
        typename View::y_coord_t y;
        try {
            for (y=0; y<img_view.height(); ++y)
                detail::default_construct_aux(img_view.row_begin(y),img_view.row_end(y), is_planar<View>());
        } catch(...) {
            for (typename View::y_coord_t y0=0; y0<y; ++y0)
                detail::destruct_aux(img_view.row_begin(y0),img_view.row_end(y0), is_planar<View>());
            throw;
        }
    }
}




namespace detail {

template <typename It1, typename It2>
GIL_FORCEINLINE 
void uninitialized_copy_aux(It1 first1, It1 last1,
                            It2 first2, mpl::true_) {
    int channel=0;
    try {
        typedef typename std::iterator_traits<It1>::value_type pixel_t;
        while (channel < num_channels<pixel_t>::value) {
            std::uninitialized_copy(dynamic_at_c(first1,channel), dynamic_at_c(last1,channel), dynamic_at_c(first2,channel));
            ++channel;
        }
    } catch (...) {
        It2 last2=first2;
        std::advance(last2, std::distance(first1,last1));
        for (int c=0; c<channel; ++c)
            destruct_range(dynamic_at_c(first2,c), dynamic_at_c(last2,c));
        throw;
    }
}
template <typename It1, typename It2>
GIL_FORCEINLINE 
void uninitialized_copy_aux(It1 first1, It1 last1,
                            It2 first2,mpl::false_) {
    std::uninitialized_copy(first1,last1,first2);
}
} // namespace detail

template <typename View1, typename View2> 
void uninitialized_copy_pixels(const View1& view1, const View2& view2) {
    typedef mpl::bool_<is_planar<View1>::value && is_planar<View2>::value> is_planar;  
    assert(view1.dimensions()==view2.dimensions());
    if (view1.is_1d_traversable() && view2.is_1d_traversable())
        detail::uninitialized_copy_aux(view1.begin().x(), view1.end().x(), 
                                       view2.begin().x(), 
                                       is_planar());
    else {
        typename View1::y_coord_t y;
        try {
            for (y=0; y<view1.height(); ++y)
                detail::uninitialized_copy_aux(view1.row_begin(y), view1.row_end(y),
                                               view2.row_begin(y),
                                               is_planar());
        } catch(...) {
            for (typename View1::y_coord_t y0=0; y0<y; ++y0)
                detail::destruct_aux(view2.row_begin(y0),view2.row_end(y0), is_planar());
            throw;
        }
    }
}



template <typename V, typename F>
F for_each_pixel(const V& img, F fun) {
    if (img.is_1d_traversable()) {
        return std::for_each(img.begin().x(), img.end().x(), fun);
    } else {
        for (std::ptrdiff_t 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 (std::ptrdiff_t y=0; y<img.height(); ++y) {
        for (std::ptrdiff_t x=0; x<img.width(); ++x, ++loc.x())
            fun(loc);
        loc.x()-=img.width(); ++loc.y();
    }
    return fun;
}




template <typename View, typename F>
void generate_pixels(const View& v, F fun) {
    if (v.is_1d_traversable()) {
        std::generate(v.begin().x(), v.end().x(), fun);
    } else {
        for (std::ptrdiff_t y=0; y<v.height(); ++y)
            std::generate(v.row_begin(y),v.row_end(y),fun);
    }
}



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_pixel_iterator<IC,Cs>, planar_pixel_iterator<IC,Cs> > {
    GIL_FORCEINLINE bool operator()(const planar_pixel_iterator<IC,Cs> i1, std::ptrdiff_t n, const planar_pixel_iterator<IC,Cs> i2) const { 
        ptrdiff_t numBytes=n*sizeof(typename std::iterator_traits<IC>::value_type);

        for (std::ptrdiff_t i=0; i<mpl::size<Cs>::value; ++i)
            if (memcmp(dynamic_at_c(i1,i), dynamic_at_c(i2,i), numBytes)!=0)
                return false;
        return true;
    }
};


template <typename Loc, typename I2>  // IL Models ConstPixelLocatorConcept, O Models PixelIteratorConcept
struct equal_n_fn<boost::gil::iterator_from_2d<Loc>,I2> {
    GIL_FORCEINLINE bool operator()(boost::gil::iterator_from_2d<Loc> i1, std::ptrdiff_t n, I2 i2) const {
        gil_function_requires<boost::gil::PixelLocatorConcept<Loc> >();
        gil_function_requires<boost::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,boost::gil::iterator_from_2d<Loc> > {
    GIL_FORCEINLINE bool operator()(I1 i1, std::ptrdiff_t n, boost::gil::iterator_from_2d<Loc> i2) const {
        gil_function_requires<boost::gil::PixelIteratorConcept<I1> >();
        gil_function_requires<boost::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<boost::gil::iterator_from_2d<Loc1>,boost::gil::iterator_from_2d<Loc2> > {
   GIL_FORCEINLINE bool operator()(boost::gil::iterator_from_2d<Loc1> i1, std::ptrdiff_t n, boost::gil::iterator_from_2d<Loc2> i2) const {
        gil_function_requires<boost::gil::PixelLocatorConcept<Loc1> >();
        gil_function_requires<boost::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;
    }
};
} // namespace detail

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);
}
} }  // namespace boost::gil

namespace std {
template <typename Loc1, typename Loc2> GIL_FORCEINLINE 
bool equal(boost::gil::iterator_from_2d<Loc1> first, boost::gil::iterator_from_2d<Loc1> last, boost::gil::iterator_from_2d<Loc2> first2) {
    boost::gil::gil_function_requires<boost::gil::PixelLocatorConcept<Loc1> >();
    boost::gil::gil_function_requires<boost::gil::PixelLocatorConcept<Loc2> >();
    std::ptrdiff_t n=last-first;
    if (first.is_1d_traversable()) {
        if (first2.is_1d_traversable())
            return boost::gil::detail::equal_n_fn<typename Loc1::x_iterator,typename Loc2::x_iterator>()(first.x(),n, first2.x());
        else
            return boost::gil::detail::equal_n_fn<typename Loc1::x_iterator,boost::gil::iterator_from_2d<Loc2> >()(first.x(),n, first2);
    } else {
        if (first2.is_1d_traversable())
            return boost::gil::detail::equal_n_fn<boost::gil::iterator_from_2d<Loc1>,typename Loc2::x_iterator>()(first,n, first2.x());
        else
            return boost::gil::detail::equal_n_fn<boost::gil::iterator_from_2d<Loc1>,boost::gil::iterator_from_2d<Loc2> >()(first,n,first2);
    }
}
} // namespace std

namespace boost { namespace gil {

template <typename View1, typename View2> GIL_FORCEINLINE 
bool equal_pixels(const View1& v1, const View2& v2) {
    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 View1, typename View2, typename F> GIL_FORCEINLINE 
F transform_pixels(const View1& src,const View2& dst, F fun) {
    assert(src.dimensions()==dst.dimensions());
    for (std::ptrdiff_t y=0; y<src.height(); ++y) {
        typename View1::x_iterator srcIt=src.row_begin(y);
        typename View2::x_iterator dstIt=dst.row_begin(y);
        for (std::ptrdiff_t x=0; x<src.width(); ++x)
            dstIt[x]=fun(srcIt[x]);
    }
    return fun;
}

template <typename View1, typename View2, typename View3, typename F> GIL_FORCEINLINE 
F transform_pixels(const View1& src1, const View2& src2,const View3& dst, F fun) {
    for (std::ptrdiff_t y=0; y<dst.height(); ++y) {
        typename View1::x_iterator srcIt1=src1.row_begin(y);
        typename View2::x_iterator srcIt2=src2.row_begin(y);
        typename View3::x_iterator dstIt=dst.row_begin(y);
        for (std::ptrdiff_t x=0; x<dst.width(); ++x)
            dstIt[x]=fun(srcIt1[x],srcIt2[x]);
    }
    return fun;
}


template <typename View1, typename View2, typename F> GIL_FORCEINLINE 
F transform_pixel_positions(const View1& src,const View2& dst, F fun) {
    assert(src.dimensions()==dst.dimensions());
    typename View1::xy_locator loc=src.xy_at(0,0);
    for (std::ptrdiff_t y=0; y<src.height(); ++y) {
        typename View2::x_iterator dstIt=dst.row_begin(y);
        for (std::ptrdiff_t x=0; x<src.width(); ++x, ++loc.x())
            dstIt[x]=fun(loc);
        loc.x()-=src.width(); ++loc.y();
    }
    return fun;
}

template <typename View1, typename View2, typename View3, typename F> GIL_FORCEINLINE 
F transform_pixel_positions(const View1& src1,const View2& src2,const View3& dst, F fun) {
    assert(src1.dimensions()==dst.dimensions());
    assert(src2.dimensions()==dst.dimensions());
    typename View1::xy_locator loc1=src1.xy_at(0,0);
    typename View2::xy_locator loc2=src2.xy_at(0,0);
    for (std::ptrdiff_t y=0; y<src1.height(); ++y) {
        typename View3::x_iterator dstIt=dst.row_begin(y);
        for (std::ptrdiff_t 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;
}

} }  // namespace boost::gil

//#ifdef _MSC_VER
//#pragma warning(pop)
//#endif

#endif