[Boost-commit] svn:boost r65879 - sandbox/gil/boost/gil

Subject: [Boost-commit] svn:boost r65879 - sandbox/gil/boost/gil
From: dsaritz_at_[hidden]
Date: 2010-10-10 12:42:08

Author: psiha
Date: 2010-10-10 12:42:02 EDT (Sun, 10 Oct 2010)
New Revision: 65879
URL: http://svn.boost.org/trac/boost/changeset/65879

Log:
Adding base GIL files (from the trunk) with various local optimizations.
Added:
   sandbox/gil/boost/gil/algorithm.hpp   (contents, props changed)
   sandbox/gil/boost/gil/color_convert.hpp   (contents, props changed)
   sandbox/gil/boost/gil/image.hpp   (contents, props changed)
   sandbox/gil/boost/gil/locator.hpp   (contents, props changed)
   sandbox/gil/boost/gil/utilities.hpp   (contents, props changed)

Added: sandbox/gil/boost/gil/algorithm.hpp
==============================================================================
--- (empty file)
+++ sandbox/gil/boost/gil/algorithm.hpp	2010-10-10 12:42:02 EDT (Sun, 10 Oct 2010)
@@ -0,0 +1,1029 @@
+/*
+    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"
+
+////////////////////////////////////////////////////////////////////////////////////////
+/// \file               
+/// \brief Some basic STL-style algorithms when applied to image views
+/// \author Lubomir Bourdev and Hailin Jin \n
+///         Adobe Systems Incorporated
+/// \date   2005-2008 \n Last updated on March 12, 2008
+///
+////////////////////////////////////////////////////////////////////////////////////////
+
+//#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 {};
+
+/// \defgroup ImageViewSTLAlgorithms STL-like Algorithms
+/// \ingroup ImageViewAlgorithm
+/// \brief Image view-equivalents of STL algorithms
+///
+/// Image views provide 1D iteration of their pixels via \p begin() and \p end() methods,
+/// which makes it possible to use STL algorithms with them. However, using nested loops
+/// over X and Y is in many cases more efficient. The algorithms in this section resemble
+/// STL algorithms, but they abstract away the nested loops and take views (as opposed to ranges) as input.
+///
+/// Most algorithms check whether the image views are 1D-traversable. A 1D-traversable image view has no gaps
+/// at the end of the rows. In other words, if an x_iterator of that view is advanced past the last pixel in a row
+/// it will move to the first pixel of the next row. When image views are 1D-traversable, the algorithms use
+/// a single loop and run more efficiently. If one or more of the input views are not 1D-traversable, the algorithms
+/// fall-back to an X-loop nested inside a Y-loop.
+///
+/// The algorithms typically delegate the work to their corresponding STL algorithms. For example, \p copy_pixels calls
+/// \p std::copy either for each row, or, when the images are 1D-traversable, once for all pixels.
+///
+/// In addition, overloads are sometimes provided for the STL algorithms. For example, std::copy for planar iterators
+/// is overloaded to perform \p std::copy for each of the planes. \p std::copy over bitwise-copiable pixels results in
+/// std::copy over unsigned char, which STL typically implements via \p memmove.
+///
+/// As a result \p copy_pixels may result in a single call to \p memmove for interleaved 1D-traversable views, 
+/// or one per each plane of planar 1D-traversable views, or one per each row of interleaved non-1D-traversable images, etc.
+
+
+/// \defgroup STLOptimizations  Performance overloads of STL algorithms
+/// \ingroup ImageViewAlgorithm
+/// \brief overloads of STL algorithms allowing more efficient implementation when used with GIL constructs
+
+/// \brief A generic binary operation on views
+/// \ingroup ImageViewSTLAlgorithms
+///
+/// Use this class as a convenience superclass when defining an operation for any image views.
+/// Many operations have different behavior when the two views are compatible. This class checks
+/// for compatibility and invokes apply_compatible(V1,V2) or apply_incompatible(V1,V2) of the subclass.
+/// You must provide apply_compatible(V1,V2) method in your subclass, but apply_incompatible(V1,V2)
+/// is not required and the default throws std::bad_cast.
+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
+
+//////////////////////////////////////////////////////////////////////////////////////
+///
+/// std::copy and gil::copy_pixels
+///
+//////////////////////////////////////////////////////////////////////////////////////
+
+/// \defgroup ImageViewSTLAlgorithmsCopyPixels copy_pixels
+/// \ingroup ImageViewSTLAlgorithms
+/// \brief std::copy for image views
+
+namespace std {
+
+/// \ingroup STLOptimizations
+/// \brief Copy when both src and dst are interleaved and of the same type can be just memmove
+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);
+}
+
+/// \ingroup STLOptimizations
+/// \brief Copy when both src and dst are interleaved and of the same type can be just memmove
+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 {
+/// \ingroup STLOptimizations
+/// \brief Copy when both src and dst are planar pointers is copy for each channel
+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 {
+/// Does a copy-n. If the inputs contain image iterators, performs a copy at each row using the row iterators
+/// \ingroup CopyPixels
+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); }
+};
+
+/// Source range is delimited by image iterators
+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;
+        }
+    }
+};
+
+/// Destination range is delimited by image iterators
+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;
+        }
+    }
+};
+
+/// Both source and destination ranges are delimited by image iterators
+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 {
+/// \ingroup STLOptimizations
+/// \brief  std::copy(I1,I1,I2) with I1 and I2 being a iterator_from_2d
+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 {
+
+
+/// \ingroup ImageViewSTLAlgorithmsCopyPixels
+/// \brief std::copy for image views
+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());
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+///
+/// copy_and_convert_pixels
+///
+//////////////////////////////////////////////////////////////////////////////////////
+
+/// \defgroup ImageViewSTLAlgorithmsCopyAndConvertPixels copy_and_convert_pixels
+/// \ingroup ImageViewSTLAlgorithms
+/// \brief copies src view into dst view, color converting if necessary.
+///
+/// Versions taking static and runtime views are provided. Versions taking user-defined color convered are provided.
+
+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
+
+/// \ingroup ImageViewSTLAlgorithmsCopyAndConvertPixels
+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;
+
+/// \ingroup ImageViewSTLAlgorithmsCopyAndConvertPixels
+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
+//
+//////////////////////////////////////////////////////////////////////////////////////
+
+/// \defgroup ImageViewSTLAlgorithmsFillPixels fill_pixels
+/// \ingroup ImageViewSTLAlgorithms
+/// \brief std::fill for image views
+
+
+namespace std {
+/// \ingroup STLOptimizations
+/// \brief std::fill(I,I,V) with I being a iterator_from_2d
+///
+/// Invoked when one calls std::fill(I,I,V) with I being a iterator_from_2d (which is
+/// a 1D iterator over the pixels in an image). For contiguous images (i.e. images that have
+/// no alignment gap at the end of each row) it is more efficient to use the underlying 
+/// pixel iterator that does not check for the end of rows. For non-contiguous images fill
+/// resolves to fill of each row using the underlying pixel iterator, which is still faster
+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 to do std::fill
+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);
+    }
+};
+/// std::fill for planar iterators
+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());
+}
+/// std::fill for interleaved iterators
+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
+
+/// \ingroup ImageViewSTLAlgorithmsFillPixels
+/// \brief std::fill for image views
+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>());
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+///
+/// destruct_pixels
+///
+//////////////////////////////////////////////////////////////////////////////////////
+
+/// \defgroup ImageViewSTLAlgorithmsDestructPixels destruct_pixels
+/// \ingroup ImageViewSTLAlgorithms
+/// \brief invokes the destructor on every pixel of an image 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, It, 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); }
+};
+
+/// destruct for planar iterators
+template <typename It>
+GIL_FORCEINLINE 
+void destruct_aux(It first, It last, mpl::true_) {
+    static_for_each(first,last,std_destruct_t());
+}
+/// destruct for interleaved iterators
+template <typename It>
+GIL_FORCEINLINE 
+void destruct_aux(It first, It last, mpl::false_) {
+    destruct_range(first,last);
+}
+
+} // namespace detail
+
+/// \ingroup ImageViewSTLAlgorithmsDestructPixels
+/// \brief Invokes the in-place destructor on every pixel of the view
+template <typename View> GIL_FORCEINLINE 
+void destruct_pixels(const View& img_view) {
+    // Implementation note:
+    //    The 'skip' in/through destruct_aux() is not enough as MSVC++ 10 still
+    // generates code for the bloated img_view.end() call.
+    //                                        (10.10.2010.) (Domagoj Saric)
+    if ( view_is_basic<View>::value )
+        return;
+    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>());
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+///
+/// uninitialized_fill_pixels
+///
+//////////////////////////////////////////////////////////////////////////////////////
+
+/// \defgroup ImageViewSTLAlgorithmsUninitializedFillPixels uninitialized_fill_pixels
+/// \ingroup ImageViewSTLAlgorithms
+/// \brief std::uninitialized_fill for image views
+
+
+namespace detail {
+
+/// std::uninitialized_fill for planar iterators
+/// If an exception is thrown destructs any in-place copy-constructed objects
+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;
+    }
+}
+
+/// std::uninitialized_fill for interleaved iterators
+/// If an exception is thrown destructs any in-place copy-constructed objects
+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
+
+/// \ingroup ImageViewSTLAlgorithmsUninitializedFillPixels
+/// \brief std::uninitialized_fill for image views.
+/// Does not support planar heterogeneous views.
+/// If an exception is thrown destructs any in-place copy-constructed pixels
+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;
+        }
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+///
+/// default_construct_pixels
+///
+//////////////////////////////////////////////////////////////////////////////////////
+
+/// \defgroup ImageViewSTLAlgorithmsDefaultConstructPixels default_construct_pixels
+/// \ingroup ImageViewSTLAlgorithms
+/// \brief invokes the default constructor on every pixel of an image view
+
+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, It, 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()); }
+
+/// uninitialized_default_construct for planar iterators
+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;
+    }
+}
+
+/// uninitialized_default_construct for interleaved iterators
+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
+
+/// \ingroup ImageViewSTLAlgorithmsDefaultConstructPixels
+/// \brief Invokes the in-place default constructor on every pixel of the (uninitialized) view.
+/// Does not support planar heterogeneous views.
+/// If an exception is thrown destructs any in-place default-constructed pixels
+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;
+        }
+    }
+}
+
+
+//////////////////////////////////////////////////////////////////////////////////////
+///
+/// uninitialized_copy_pixels
+///
+//////////////////////////////////////////////////////////////////////////////////////
+
+/// \defgroup ImageViewSTLAlgorithmsUninitializedCopyPixels uninitialized_copy_pixels
+/// \ingroup ImageViewSTLAlgorithms
+/// \brief std::uninitialized_copy for image views
+
+namespace detail {
+
+/// std::uninitialized_copy for pairs of planar iterators
+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;
+    }
+}
+/// std::uninitialized_copy for interleaved or mixed iterators
+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
+
+/// \ingroup ImageViewSTLAlgorithmsUninitializedCopyPixels
+/// \brief std::uninitialized_copy for image views.
+/// Does not support planar heterogeneous views.
+/// If an exception is thrown destructs any in-place copy-constructed objects
+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;
+        }
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+///
+/// for_each_pixel
+///
+//////////////////////////////////////////////////////////////////////////////////////
+
+/// \defgroup ImageViewSTLAlgorithmsForEachPixel for_each_pixel
+/// \ingroup ImageViewSTLAlgorithms
+/// \brief std::for_each for image views
+///
+/// For contiguous images (i.e. images that have no alignment gap at the end of each row) it is 
+/// more efficient to use the underlying pixel iterator that does not check for the end of rows. 
+/// For non-contiguous images for_each_pixel resolves to for_each of each row using the underlying 
+/// pixel iterator, which is still faster
+
+/// \ingroup ImageViewSTLAlgorithmsForEachPixel
+template <typename V, typename F>
+F for_each_pixel(const V& img, F fun) {
+    typename V::x_iterator       begin( img.x_at( 0, 0            ) );
+    typename V::x_iterator const end  ( img.x_at( 0, img.height() ) );
+    if ( img.is_1d_traversable() ) {
+        return std::for_each( begin, end, fun );
+    } else {
+        typename V::y_iterator current_row_end( img.col_begin( img.width() ) );
+        while ( begin != end )
+        {
+            fun = std::for_each( begin, current_row_end.base(), fun );
+            memunit_advance( begin, current_row_end.step() );
+            ++current_row_end;
+        }
+        return fun;
+    }
+}
+
+/// \defgroup ImageViewSTLAlgorithmsForEachPixelPosition for_each_pixel_position
+/// \ingroup ImageViewSTLAlgorithms
+/// \brief adobe::for_each_position for image views (passes locators, instead of pixel references, to the function object)
+
+/// \ingroup ImageViewSTLAlgorithmsForEachPixelPosition
+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;
+}
+
+
+//////////////////////////////////////////////////////////////////////////////////////
+///
+/// generate_pixels
+///
+//////////////////////////////////////////////////////////////////////////////////////
+
+/// \defgroup ImageViewSTLAlgorithmsGeneratePixels generate_pixels
+/// \ingroup ImageViewSTLAlgorithms
+/// \brief std::generate for image views
+
+/// \ingroup ImageViewSTLAlgorithmsGeneratePixels
+/// \brief std::generate for image views
+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);
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+///
+/// std::equal and gil::equal_pixels for GIL constructs
+///
+//////////////////////////////////////////////////////////////////////////////////////
+
+/// \defgroup ImageViewSTLAlgorithmsEqualPixels equal_pixels
+/// \ingroup ImageViewSTLAlgorithms
+/// \brief std::equal for image views
+
+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); }
+};
+
+/// Equal when both ranges are interleaved and of the same type. 
+/// GIL pixels are bitwise comparable, so memcmp is used. User-defined pixels that are not bitwise comparable need to provide an overload
+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>*> {};
+
+/// EqualPixels
+/// Equal when both ranges are planar pointers of the same type. memcmp is invoked for each channel plane
+///  User-defined channels that are not bitwise comparable need to provide an overload
+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;
+    }
+};
+
+
+/// Source range is delimited by image iterators
+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;
+    }
+};
+
+/// Destination range is delimited by image iterators
+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;
+    }
+};
+
+/// Both source and destination ranges are delimited by image iterators
+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 {
+/// \ingroup STLOptimizations
+/// \brief  std::equal(I1,I1,I2) with I1 and I2 being a iterator_from_2d
+///
+/// Invoked when one calls std::equal(I1,I1,I2) with I1 and I2 being a iterator_from_2d (which is
+/// a 1D iterator over the pixels in an image). Attempts to demote the source and destination 
+/// iterators to simpler/faster types if the corresponding range is contiguous.
+/// For contiguous images (i.e. images that have
+/// no alignment gap at the end of each row) it is more efficient to use the underlying 
+/// pixel iterator that does not check for the end of rows. If the underlying pixel iterator
+/// happens to be a fundamental planar/interleaved pointer, the call may further resolve
+/// to memcmp. Otherwise it resolves to copying each row using the underlying pixel iterator
+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 {
+
+/// \ingroup ImageViewSTLAlgorithmsEqualPixels
+/// \brief std::equal for image views
+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
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+///
+/// transform_pixels
+///
+//////////////////////////////////////////////////////////////////////////////////////
+
+/// \defgroup ImageViewSTLAlgorithmsTransformPixels transform_pixels
+/// \ingroup ImageViewSTLAlgorithms
+/// \brief std::transform for image views
+
+/// \ingroup ImageViewSTLAlgorithmsTransformPixels
+/// \brief std::transform for image views
+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;
+}
+
+/// \ingroup ImageViewSTLAlgorithmsTransformPixels
+/// \brief transform_pixels with two sources
+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;
+}
+
+/// \defgroup ImageViewSTLAlgorithmsTransformPixelPositions transform_pixel_positions
+/// \ingroup ImageViewSTLAlgorithms
+/// \brief adobe::transform_positions for image views (passes locators, instead of pixel references, to the function object) 
+
+/// \ingroup ImageViewSTLAlgorithmsTransformPixelPositions
+/// \brief Like transform_pixels but passes to the function object pixel locators instead of pixel references
+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;
+}
+
+/// \ingroup ImageViewSTLAlgorithmsTransformPixelPositions
+/// \brief transform_pixel_positions with two sources
+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

Added: sandbox/gil/boost/gil/color_convert.hpp
==============================================================================
--- (empty file)
+++ sandbox/gil/boost/gil/color_convert.hpp	2010-10-10 12:42:02 EDT (Sun, 10 Oct 2010)
@@ -0,0 +1,321 @@
+/*
+    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_COLOR_CONVERT_HPP
+#define GIL_COLOR_CONVERT_HPP
+
+////////////////////////////////////////////////////////////////////////////////////////
+/// \file               
+/// \brief GIL default color space conversions
+/// \author Lubomir Bourdev and Hailin Jin \n
+///         Adobe Systems Incorporated
+/// \date   2005-2007 \n Last updated on January 30, 2007
+///
+/// Support for fast and simple color conversion. Accurate color conversion using color
+/// profiles can be supplied separately in a dedicated module
+///
+////////////////////////////////////////////////////////////////////////////////////////
+
+#include <functional>
+#include "gil_config.hpp"
+#include "channel_algorithm.hpp"
+#include "pixel.hpp"
+#include "gray.hpp"
+#include "rgb.hpp"
+#include "rgba.hpp"
+#include "cmyk.hpp"
+#include "metafunctions.hpp"
+#include "utilities.hpp"
+#include "color_base_algorithm.hpp"
+
+namespace boost { namespace gil {
+
+// Forward-declare
+template <typename P> struct channel_type;
+
+////////////////////////////////////////////////////////////////////////////////////////
+///                 
+///                 COLOR SPACE CONVERSION
+///
+////////////////////////////////////////////////////////////////////////////////////////
+
+/// \ingroup ColorConvert 
+/// \brief Color Convertion function object. To be specialized for every src/dst color space
+template <typename C1, typename C2>
+struct default_color_converter_impl {};
+
+/// \ingroup ColorConvert
+/// \brief When the color space is the same, color convertion performs channel depth conversion
+template <typename C>
+struct default_color_converter_impl<C,C> {
+    template <typename P1, typename P2>
+    void operator()(const P1& src, P2& dst) const {
+        static_for_each(src,dst,default_channel_converter());
+    }
+};
+
+namespace detail {
+
+/// red * .3 + green * .59 + blue * .11 + .5
+
+// The default implementation of to_luminance uses float0..1 as the intermediate channel type
+template <typename RedChannel, typename GreenChannel, typename BlueChannel, typename GrayChannelValue>
+struct rgb_to_luminance_fn {
+    GrayChannelValue operator()(const RedChannel& red, const GreenChannel& green, const BlueChannel& blue) const {
+        return channel_convert<GrayChannelValue>( bits32f(
+            channel_convert<bits32f>(red  )*0.30f + 
+            channel_convert<bits32f>(green)*0.59f + 
+            channel_convert<bits32f>(blue )*0.11f) );
+    }
+};
+
+// performance specialization for unsigned char
+template <typename GrayChannelValue>
+struct rgb_to_luminance_fn<uint8_t,uint8_t,uint8_t, GrayChannelValue> {
+    GrayChannelValue operator()(uint8_t red, uint8_t green, uint8_t blue) const {
+        return channel_convert<GrayChannelValue>(uint8_t(
+            ((uint32_t(red  )*4915 + uint32_t(green)*9667 + uint32_t(blue )*1802) + 8192) >> 14));
+    }
+};
+
+template <typename GrayChannel, typename RedChannel, typename GreenChannel, typename BlueChannel>
+typename channel_traits<GrayChannel>::value_type rgb_to_luminance(const RedChannel& red, const GreenChannel& green, const BlueChannel& blue) {
+    return rgb_to_luminance_fn<RedChannel,GreenChannel,BlueChannel,
+                               typename channel_traits<GrayChannel>::value_type>()(red,green,blue);
+}
+
+}   // namespace detail
+
+/// \ingroup ColorConvert
+/// \brief Gray to RGB
+template <>
+struct default_color_converter_impl<gray_t,rgb_t> {
+    template <typename P1, typename P2>
+    void operator()(const P1& src, P2& dst) const {
+        get_color(dst,red_t())  =
+            channel_convert<typename color_element_type<P2, red_t  >::type>(get_color(src,gray_color_t()));
+        get_color(dst,green_t())=
+            channel_convert<typename color_element_type<P2, green_t>::type>(get_color(src,gray_color_t()));
+        get_color(dst,blue_t()) =
+            channel_convert<typename color_element_type<P2, blue_t >::type>(get_color(src,gray_color_t()));
+    }
+};
+
+/// \ingroup ColorConvert
+/// \brief Gray to CMYK
+template <>
+struct default_color_converter_impl<gray_t,cmyk_t> {
+    template <typename P1, typename P2>
+    void operator()(const P1& src, P2& dst) const {
+        get_color(dst,cyan_t())=
+            channel_traits<typename color_element_type<P2, cyan_t   >::type>::min_value();
+        get_color(dst,magenta_t())=
+            channel_traits<typename color_element_type<P2, magenta_t>::type>::min_value();
+        get_color(dst,yellow_t())=
+            channel_traits<typename color_element_type<P2, yellow_t >::type>::min_value();
+        get_color(dst,black_t())=
+            channel_convert<typename color_element_type<P2, black_t >::type>(get_color(src,gray_color_t()));
+    }
+};
+
+/// \ingroup ColorConvert
+/// \brief RGB to Gray
+template <>
+struct default_color_converter_impl<rgb_t,gray_t> {
+    template <typename P1, typename P2>
+    void operator()(const P1& src, P2& dst) const {
+        get_color(dst,gray_color_t()) = 
+            detail::rgb_to_luminance<typename color_element_type<P2,gray_color_t>::type>(
+                get_color(src,red_t()), get_color(src,green_t()), get_color(src,blue_t())
+            );
+    }
+};
+
+
+/// \ingroup ColorConvert
+/// \brief RGB to CMYK (not the fastest code in the world)
+///
+/// k = min(1 - r, 1 - g, 1 - b)
+/// c = (1 - r - k) / (1 - k)
+/// m = (1 - g - k) / (1 - k)
+/// y = (1 - b - k) / (1 - k)
+template <>
+struct default_color_converter_impl<rgb_t,cmyk_t> {
+    template <typename P1, typename P2>
+    void operator()(const P1& src, P2& dst) const {
+        typedef typename channel_type<P2>::type T2;
+        get_color(dst,cyan_t())    = channel_invert(channel_convert<T2>(get_color(src,red_t())));          // c = 1 - r
+        get_color(dst,magenta_t()) = channel_invert(channel_convert<T2>(get_color(src,green_t())));        // m = 1 - g
+        get_color(dst,yellow_t())  = channel_invert(channel_convert<T2>(get_color(src,blue_t())));         // y = 1 - b
+        get_color(dst,black_t())   = (std::min)(get_color(dst,cyan_t()),
+                                                (std::min)(get_color(dst,magenta_t()),
+                                                           get_color(dst,yellow_t())));   // k = minimum(c, m, y)
+        T2 x = channel_traits<T2>::max_value()-get_color(dst,black_t());                  // x = 1 - k
+        if (x>0.0001f) {
+            float x1 = channel_traits<T2>::max_value()/float(x);
+            get_color(dst,cyan_t())    = (T2)((get_color(dst,cyan_t())    - get_color(dst,black_t()))*x1);                // c = (c - k) / x
+            get_color(dst,magenta_t()) = (T2)((get_color(dst,magenta_t()) - get_color(dst,black_t()))*x1);                // m = (m - k) / x
+            get_color(dst,yellow_t())  = (T2)((get_color(dst,yellow_t())  - get_color(dst,black_t()))*x1);                // y = (y - k) / x
+        } else {
+            get_color(dst,cyan_t())=get_color(dst,magenta_t())=get_color(dst,yellow_t())=0;
+        }
+    }
+};
+
+/// \ingroup ColorConvert
+/// \brief CMYK to RGB (not the fastest code in the world)
+///
+/// r = 1 - min(1, c*(1-k)+k)
+/// g = 1 - min(1, m*(1-k)+k)
+/// b = 1 - min(1, y*(1-k)+k)
+template <>
+struct default_color_converter_impl<cmyk_t,rgb_t> {
+    template <typename P1, typename P2>
+    void operator()(const P1& src, P2& dst) const {
+        typedef typename channel_type<P1>::type T1;
+        typedef typename mpl::if_
+            <
+                is_integral<T1>,
+                typename detail::min_fast_uint<sizeof( T1 ) * 8 + 1>::type,
+                T1
+            >::type T1_AUX;
+        get_color(dst,red_t())  =
+            channel_convert<typename color_element_type<P2,red_t>::type>
+            (
+                //channel_invert(T1(get_color(src,cyan_t())*channel_invert(get_color(src,black_t()))/channel_traits<T1>::max_value() + get_color(src,black_t())))
+                T1(channel_invert(get_color(src,cyan_t()))*channel_invert(get_color(src,black_t()))/channel_traits<T1>::max_value())
+            );
+        get_color(dst,green_t())=
+            channel_convert<typename color_element_type<P2,green_t>::type>(
+                //channel_invert(T1(get_color(src,magenta_t())*channel_invert(get_color(src,black_t()))/channel_traits<T1>::max_value() + get_color(src,black_t())))
+                T1(channel_invert(get_color(src,magenta_t()))*channel_invert(get_color(src,black_t()))/channel_traits<T1>::max_value())
+                );
+        get_color(dst,blue_t()) =
+            channel_convert<typename color_element_type<P2,blue_t>::type>(
+                //channel_invert(T1(get_color(src,yellow_t())*channel_invert(get_color(src,black_t()))/channel_traits<T1>::max_value() + get_color(src,black_t())))
+                T1(channel_invert(get_color(src,yellow_t()))*channel_invert(get_color(src,black_t()))/channel_traits<T1>::max_value())
+                );
+    }
+};
+
+
+/// \ingroup ColorConvert
+/// \brief CMYK to Gray
+///
+/// gray = (1 - 0.212c - 0.715m - 0.0722y) * (1 - k)
+template <>
+struct default_color_converter_impl<cmyk_t,gray_t> {
+    template <typename P1, typename P2>
+    void operator()(const P1& src, P2& dst) const  {
+        get_color(dst,gray_color_t())=
+            channel_convert<typename color_element_type<P2,gray_t>::type>(
+                channel_multiply(
+                    channel_invert(
+                       detail::rgb_to_luminance<typename color_element_type<P1,black_t>::type>(
+                            get_color(src,cyan_t()), 
+                            get_color(src,magenta_t()), 
+                            get_color(src,yellow_t())
+                       )
+                    ), 
+                    channel_invert(get_color(src,black_t()))));
+    }
+};
+
+namespace detail {
+template <typename Pixel> 
+typename channel_type<Pixel>::type alpha_or_max_impl(const Pixel& p, mpl::true_) {
+    return get_color(p,alpha_t());
+}
+template <typename Pixel> 
+typename channel_type<Pixel>::type alpha_or_max_impl(const Pixel&  , mpl::false_) {
+    return channel_traits<typename channel_type<Pixel>::type>::max_value();
+}
+} // namespace detail
+
+// Returns max_value if the pixel has no alpha channel. Otherwise returns the alpha.
+template <typename Pixel> 
+typename channel_type<Pixel>::type alpha_or_max(const Pixel& p) {
+    return detail::alpha_or_max_impl(p, mpl::contains<typename color_space_type<Pixel>::type,alpha_t>());
+}
+
+
+/// \ingroup ColorConvert
+/// \brief Converting any pixel type to RGBA. Note: Supports homogeneous pixels only.
+template <typename C1>
+struct default_color_converter_impl<C1,rgba_t> {
+    template <typename P1, typename P2>
+    void operator()(const P1& src, P2& dst) const {
+        typedef typename channel_type<P2>::type T2;
+        pixel<T2,rgb_layout_t> tmp;
+        default_color_converter_impl<C1,rgb_t>()(src,tmp);
+        get_color(dst,red_t())  =get_color(tmp,red_t());
+        get_color(dst,green_t())=get_color(tmp,green_t());
+        get_color(dst,blue_t()) =get_color(tmp,blue_t());
+        get_color(dst,alpha_t())=channel_convert<T2>(alpha_or_max(src));
+    }
+};
+
+/// \ingroup ColorConvert
+///  \brief Converting RGBA to any pixel type. Note: Supports homogeneous pixels only.
+///
+/// Done by multiplying the alpha to get to RGB, then converting the RGB to the target pixel type
+/// Note: This may be slower if the compiler doesn't optimize out constructing/destructing a temporary RGB pixel. 
+///       Consider rewriting if performance is an issue
+template <typename C2>
+struct default_color_converter_impl<rgba_t,C2> {
+    template <typename P1, typename P2>
+    void operator()(const P1& src, P2& dst) const {
+        typedef typename channel_type<P1>::type T1;
+        default_color_converter_impl<rgb_t,C2>()(
+            pixel<T1,rgb_layout_t>(channel_multiply(get_color(src,red_t()),  get_color(src,alpha_t())), 
+                                   channel_multiply(get_color(src,green_t()),get_color(src,alpha_t())), 
+                                   channel_multiply(get_color(src,blue_t()), get_color(src,alpha_t())))
+            ,dst);
+    }
+};
+
+/// \ingroup ColorConvert
+/// \brief Unfortunately RGBA to RGBA must be explicitly provided - otherwise we get ambiguous specialization error.
+template <>
+struct default_color_converter_impl<rgba_t,rgba_t> {
+    template <typename P1, typename P2>
+    void operator()(const P1& src, P2& dst) const {
+        static_for_each(src,dst,default_channel_converter());
+    }
+};
+
+/// @defgroup ColorConvert Color Space Converion
+/// \ingroup ColorSpaces
+/// \brief Support for conversion between pixels of different color spaces and channel depths
+
+/// \ingroup PixelAlgorithm ColorConvert
+/// \brief class for color-converting one pixel to another
+struct default_color_converter {
+    template <typename SrcP, typename DstP>
+    void operator()(const SrcP& src,DstP& dst) const { 
+        typedef typename color_space_type<SrcP>::type SrcColorSpace;
+        typedef typename color_space_type<DstP>::type DstColorSpace;
+        default_color_converter_impl<SrcColorSpace,DstColorSpace>()(src,dst);
+    }
+};
+
+/// \ingroup PixelAlgorithm
+/// \brief helper function for converting one pixel to another using GIL default color-converters
+///     where ScrP models HomogeneousPixelConcept
+///           DstP models HomogeneousPixelValueConcept
+template <typename SrcP, typename DstP>
+inline void color_convert(const SrcP& src, DstP& dst) {
+    default_color_converter()(src,dst);
+}
+
+} }  // namespace boost::gil
+
+#endif

Added: sandbox/gil/boost/gil/image.hpp
==============================================================================
--- (empty file)
+++ sandbox/gil/boost/gil/image.hpp	2010-10-10 12:42:02 EDT (Sun, 10 Oct 2010)
@@ -0,0 +1,312 @@
+/*
+    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_IMAGE_H
+#define GIL_IMAGE_H
+
+////////////////////////////////////////////////////////////////////////////////////////
+/// \file               
+/// \brief Templated image
+/// \author Lubomir Bourdev and Hailin Jin \n
+///         Adobe Systems Incorporated
+/// \date 2005-2007 \n Last updated on February 12, 2007
+///
+////////////////////////////////////////////////////////////////////////////////////////
+
+#include <cstddef>
+#include <memory>
+#include "gil_config.hpp"
+#include "image_view.hpp"
+#include "metafunctions.hpp"
+#include "algorithm.hpp"
+
+namespace boost { namespace gil {
+
+//#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
+
+////////////////////////////////////////////////////////////////////////////////////////
+/// \ingroup ImageModel PixelBasedModel
+/// \brief container interface over image view. Models ImageConcept, PixelBasedConcept
+/// 
+/// A 2D container whose elements are pixels. It is templated over the pixel type, a boolean
+/// indicating whether it should be planar, and an optional allocator.
+///
+/// Note that its element type does not have to be a pixel. \p image can be instantiated with any Regular element, 
+/// in which case it models the weaker RandomAccess2DImageConcept and does not model PixelBasedConcept
+///
+////////////////////////////////////////////////////////////////////////////////////////
+
+template< typename Pixel, bool IsPlanar = false, typename Alloc=std::allocator<unsigned char> >    
+class image {
+public:
+    typedef typename Alloc::template rebind<unsigned char>::other allocator_type;
+    typedef typename view_type_from_pixel<Pixel, IsPlanar>::type view_t;
+    typedef typename view_t::const_t                 const_view_t;
+    typedef typename view_t::point_t                 point_t;
+    typedef typename view_t::coord_t                 coord_t;
+    typedef typename view_t::value_type              value_type;
+    typedef coord_t                                  x_coord_t;
+    typedef coord_t                                  y_coord_t;
+
+    const point_t&          dimensions()            const { return _view.dimensions(); }
+    x_coord_t               width()                 const { return _view.width(); }
+    y_coord_t               height()                const { return _view.height(); }
+
+    explicit image(std::size_t alignment=0,
+                   const Alloc alloc_in = Alloc()) : 
+        _memory(0), _align_in_bytes(alignment), _alloc(alloc_in) {}
+
+    // Create with dimensions and optional initial value and alignment
+    image(const point_t& dimensions,
+          std::size_t alignment=0,
+          const Alloc alloc_in = Alloc()) : _memory(0), _align_in_bytes(alignment), _alloc(alloc_in) {
+        allocate_and_default_construct(dimensions);
+    }
+    image(x_coord_t width, y_coord_t height,
+          std::size_t alignment=0,
+          const Alloc alloc_in = Alloc()) : _memory(0), _align_in_bytes(alignment), _alloc(alloc_in) {
+        allocate_and_default_construct(point_t(width,height));
+    }
+    image(const point_t& dimensions, 
+          const Pixel& p_in,
+          std::size_t alignment,
+          const Alloc alloc_in = Alloc())  :
+        _memory(0), _align_in_bytes(alignment), _alloc(alloc_in) {
+        allocate_and_fill(dimensions, p_in);
+    }
+    image(x_coord_t width, y_coord_t height,
+          const Pixel& p_in,
+          std::size_t alignment,
+          const Alloc alloc_in = Alloc())  :
+        _memory(0), _align_in_bytes(alignment), _alloc(alloc_in) {
+        allocate_and_fill(point_t(width,height),p_in);
+    }
+
+    image(const image& img) :
+        _memory(0), _align_in_bytes(img._align_in_bytes), _alloc(img._alloc) {
+        allocate_and_copy(img.dimensions(),img._view);
+    }
+
+    template <typename P2, bool IP2, typename Alloc2>
+    image(const image<P2,IP2,Alloc2>& img) : 
+        _memory(0), _align_in_bytes(img._align_in_bytes), _alloc(img._alloc) {
+       allocate_and_copy(img.dimensions(),img._view);
+    }
+    image& operator=(const image& img) {
+        if (dimensions() == img.dimensions())
+            copy_pixels(img._view,_view);
+        else {
+            image tmp(img);
+            swap(tmp);
+        }
+        return *this;
+    }
+
+    template <typename Img>
+    image& operator=(const Img& img) {
+        if (dimensions() == img.dimensions())
+            copy_pixels(img._view,_view);
+        else {
+            image tmp(img);
+            swap(tmp);
+        }
+        return *this;
+    }
+
+    ~image() {
+        destruct_pixels(_view);
+        deallocate(_view.dimensions());
+    }
+
+    Alloc&       allocator() { return _alloc; }
+    Alloc const& allocator() const { return _alloc; }
+
+    void swap(image& img) { // required by MutableContainerConcept
+        using std::swap;
+        swap(_align_in_bytes, img._align_in_bytes);
+        swap(_memory,         img._memory);
+        swap(_view,           img._view); 
+        swap(_alloc,          img._alloc);
+    }    
+
+    void recreate(const point_t& dims, std::size_t alignment=0, const Alloc alloc_in = Alloc()) {
+        if (dims!=_view.dimensions() || _align_in_bytes!=alignment || alloc_in!=_alloc) {
+            image tmp(dims, alignment, alloc_in);
+            swap(tmp);
+        }
+    }
+    void recreate(x_coord_t width, y_coord_t height, std::size_t alignment=0, const Alloc alloc_in = Alloc()) {
+        recreate(point_t(width,height),alignment,alloc_in);
+    }
+    void recreate(const point_t& dims, 
+                  const Pixel& p_in, std::size_t alignment, const Alloc alloc_in = Alloc()) {
+        if (dims!=_view.dimensions() || _align_in_bytes!=alignment || alloc_in!=_alloc) {
+            image tmp(dims, p_in, alignment, alloc_in);
+            swap(tmp);
+        }
+    }
+    void recreate(x_coord_t width, y_coord_t height, 
+                  const Pixel& p_in, std::size_t alignment, const Alloc alloc_in = Alloc()) {
+        recreate(point_t(width,height),p_in,alignment,alloc_in);
+    }
+
+    view_t       _view;      // contains pointer to the pixels, the image size and ways to navigate pixels
+private:
+    unsigned char* _memory;
+    std::size_t    _align_in_bytes;
+    allocator_type _alloc;
+
+    void allocate_and_default_construct(const point_t& dimensions) { 
+        try {
+            allocate_(dimensions,mpl::bool_<IsPlanar>());
+            // Implementation note:
+            //    The 'skip' in/through default_construct_pixels() is not enough
+            // as MSVC++ 10 is unable to inline functions with try-catch blocks.
+            //                                (10.10.2010.) (Domagoj Saric)
+            if (!detail::has_trivial_pixel_constructor<view_t, is_planar<view_t>::value>::value)
+                default_construct_pixels(_view);
+        } catch(...) {
+            __assume
+            (
+                !view_is_basic<view_t>                                                  ::value &&
+                !detail::has_trivial_pixel_constructor<view_t, is_planar<view_t>::value>::value
+            );
+            deallocate(dimensions);
+            throw;
+        }
+    }
+
+    void allocate_and_fill(const point_t& dimensions, const Pixel& p_in) { 
+        try {
+            allocate_(dimensions,mpl::bool_<IsPlanar>());
+            uninitialized_fill_pixels(_view, p_in);
+        } catch(...) { deallocate(dimensions); throw; }
+    }
+
+    template <typename View>
+    void allocate_and_copy(const point_t& dimensions, const View& v) { 
+        try {
+            allocate_(dimensions,mpl::bool_<IsPlanar>());
+            uninitialized_copy_pixels(v,_view);
+        } catch(...) { deallocate(dimensions); throw; }
+    }
+
+    void deallocate(const point_t& dimensions) { 
+        if (_memory) _alloc.deallocate(_memory, total_allocated_size_in_bytes(dimensions));
+    }
+
+    std::size_t total_allocated_size_in_bytes(const point_t& dimensions) const {
+
+        typedef typename view_t::x_iterator x_iterator; 
+
+        // when value_type is a non-pixel, like int or float, num_channels< ... > doesn't work.
+        const std::size_t _channels_in_image = mpl::eval_if< is_pixel< value_type >
+                                                           , num_channels< view_t >
+                                                           , mpl::int_< 1 > 
+														   >::type::value;
+
+        std::size_t size_in_units = get_row_size_in_memunits(dimensions.x)*dimensions.y;
+
+        if (IsPlanar)
+            size_in_units = size_in_units * _channels_in_image ;
+
+        // return the size rounded up to the nearest byte
+        return ( size_in_units + byte_to_memunit< x_iterator >::value - 1 ) 
+            / byte_to_memunit<x_iterator>::value 
+            + ( _align_in_bytes > 0 ? _align_in_bytes - 1 : 0 ); // add extra padding in case we need to align the first image pixel
+    }
+
+    std::size_t get_row_size_in_memunits(x_coord_t width) const {   // number of units per row
+        std::size_t size_in_memunits = width*memunit_step(typename view_t::x_iterator());
+        if (_align_in_bytes>0) {
+            std::size_t alignment_in_memunits=_align_in_bytes*byte_to_memunit<typename view_t::x_iterator>::value;
+            return align(size_in_memunits, alignment_in_memunits);
+        }
+        return size_in_memunits;
+    }
+    
+    void allocate_(const point_t& dimensions, mpl::false_) {  // if it throws and _memory!=0 the client must deallocate _memory
+        _memory=_alloc.allocate(total_allocated_size_in_bytes(dimensions));
+        unsigned char* tmp=(_align_in_bytes>0) ? (unsigned char*)align((std::size_t)_memory,_align_in_bytes) : _memory;
+        _view=view_t(dimensions,typename view_t::locator(typename view_t::x_iterator(tmp),get_row_size_in_memunits(dimensions.x)));
+    }
+
+    void allocate_(const point_t& dimensions, mpl::true_) {   // if it throws and _memory!=0 the client must deallocate _memory
+        std::size_t row_size=get_row_size_in_memunits(dimensions.x);
+        std::size_t plane_size=row_size*dimensions.y;
+        _memory=_alloc.allocate(total_allocated_size_in_bytes(dimensions));
+        unsigned char* tmp=(_align_in_bytes>0) ? (unsigned char*)align((std::size_t)_memory,_align_in_bytes) : _memory;
+        typename view_t::x_iterator first; 
+        for (int i=0; i<num_channels<view_t>::value; ++i) {
+            dynamic_at_c(first,i) = (typename channel_type<view_t>::type*)tmp;
+            memunit_advance(dynamic_at_c(first,i), plane_size*i);
+        }
+        _view=view_t(dimensions, typename view_t::locator(first, row_size));
+    }
+};
+
+template <typename Pixel, bool IsPlanar, typename Alloc>
+void swap(image<Pixel, IsPlanar, Alloc>& im1,image<Pixel, IsPlanar, Alloc>& im2) {
+    im1.swap(im2); 
+}
+
+template <typename Pixel1, bool IsPlanar1, typename Alloc1, typename Pixel2, bool IsPlanar2, typename Alloc2>
+bool operator==(const image<Pixel1,IsPlanar1,Alloc1>& im1,const image<Pixel2,IsPlanar2,Alloc2>& im2) {
+    if ((void*)(&im1)==(void*)(&im2)) return true;
+    if (const_view(im1).dimensions()!=const_view(im2).dimensions()) return false;
+    return equal_pixels(const_view(im1),const_view(im2));
+}
+template <typename Pixel1, bool IsPlanar1, typename Alloc1, typename Pixel2, bool IsPlanar2, typename Alloc2>
+bool operator!=(const image<Pixel1,IsPlanar1,Alloc1>& im1,const image<Pixel2,IsPlanar2,Alloc2>& im2) {return !(im1==im2);}
+
+///@{
+/// \name view, const_view
+/// \brief Get an image view from an image
+
+/// \ingroup ImageModel
+
+/// \brief Returns the non-constant-pixel view of an image
+template <typename Pixel, bool IsPlanar, typename Alloc> inline 
+const typename image<Pixel,IsPlanar,Alloc>::view_t& view(image<Pixel,IsPlanar,Alloc>& img) { return img._view; }
+
+/// \brief Returns the constant-pixel view of an image
+template <typename Pixel, bool IsPlanar, typename Alloc> inline 
+const typename image<Pixel,IsPlanar,Alloc>::const_view_t const_view(const image<Pixel,IsPlanar,Alloc>& img) { 
+    return static_cast<const typename image<Pixel,IsPlanar,Alloc>::const_view_t>(img._view); 
+}
+///@}
+
+/////////////////////////////
+//  PixelBasedConcept
+/////////////////////////////
+
+template <typename Pixel, bool IsPlanar, typename Alloc>
+struct channel_type<image<Pixel,IsPlanar,Alloc> > : public channel_type<Pixel> {}; 
+
+template <typename Pixel, bool IsPlanar, typename Alloc>
+struct color_space_type<image<Pixel,IsPlanar,Alloc> >  : public color_space_type<Pixel> {};
+
+template <typename Pixel, bool IsPlanar, typename Alloc>
+struct channel_mapping_type<image<Pixel,IsPlanar,Alloc> > : public channel_mapping_type<Pixel> {};
+
+template <typename Pixel, bool IsPlanar, typename Alloc>
+struct is_planar<image<Pixel,IsPlanar,Alloc> > : public mpl::bool_<IsPlanar> {};
+
+//#ifdef _MSC_VER
+//#pragma warning(pop)
+//#endif
+
+} }  // namespace boost::gil
+
+#endif

Added: sandbox/gil/boost/gil/locator.hpp
==============================================================================
--- (empty file)
+++ sandbox/gil/boost/gil/locator.hpp	2010-10-10 12:42:02 EDT (Sun, 10 Oct 2010)
@@ -0,0 +1,395 @@
+/*
+    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_LOCATOR_H
+#define GIL_LOCATOR_H
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+/// \file               
+/// \brief pixel 2D locator
+/// \author Lubomir Bourdev and Hailin Jin \n
+///         Adobe Systems Incorporated
+/// \date   2005-2007 \n September 20, 2006
+///
+////////////////////////////////////////////////////////////////////////////////////////
+
+#include <cstddef>
+#include <cassert>
+#include "pixel_iterator.hpp"
+
+////////////////////////////////////////////////////////////////////////////////////////
+///                 Pixel 2D LOCATOR
+////////////////////////////////////////////////////////////////////////////////////////
+
+
+namespace boost { namespace gil {
+
+//forward declarations
+template <typename P> ptrdiff_t memunit_step(const P*);
+template <typename P> P* memunit_advanced(const P* p, ptrdiff_t diff);
+template <typename P> P& memunit_advanced_ref(P* p, ptrdiff_t diff);
+template <typename Iterator, typename D> struct iterator_add_deref;
+template <typename T> class point2;
+namespace detail {
+    // helper class specialized for each axis of pixel_2d_locator
+    template <std::size_t D, typename Loc>  class locator_axis;
+}
+template <typename T> struct dynamic_x_step_type;
+template <typename T> struct dynamic_y_step_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;
+
+// The type of a locator or a view that has X and Y swapped. By default it is the same
+template <typename T> struct transposed_type {
+    typedef T type;
+};
+
+/// \class pixel_2d_locator_base
+/// \brief base class for models of PixelLocatorConcept
+/// \ingroup PixelLocatorModel PixelBasedModel
+///
+/// Pixel locator is similar to a pixel iterator, but allows for 2D navigation of pixels within an image view. 
+/// It has a 2D difference_type and supports random access operations like:
+/// \code
+///     difference_type offset2(2,3);
+///     locator+=offset2;
+///     locator[offset2]=my_pixel;
+/// \endcode
+///
+/// In addition, each coordinate acts as a random-access iterator that can be modified separately:
+/// "++locator.x()" or "locator.y()+=10" thereby moving the locator horizontally or vertically.
+///
+/// It is called a locator because it doesn't implement the complete interface of a random access iterator.
+/// For example, increment and decrement operations don't make sense (no way to specify dimension).
+/// Also 2D difference between two locators cannot be computed without knowledge of the X position within the image.
+/// 
+/// This base class provides most of the methods and typedefs needed to create a model of a locator. GIL provides two
+/// locator models as subclasses of \p pixel_2d_locator_base. A memory-based locator, \p memory_based_2d_locator and a virtual
+/// locator, \p virtual_2d_locator.
+/// The minimum functionality a subclass must provide is this:
+/// \code
+/// class my_locator : public pixel_2d_locator_base<my_locator, ..., ...> {  // supply the types for x-iterator and y-iterator
+///        typedef ... const_t;                      // read-only locator
+///
+///        template <typename Deref> struct add_deref {
+///            typedef ... type;                     // locator that invokes the Deref dereference object upon pixel access
+///            static type make(const my_locator& loc, const Deref& d);
+///        };
+///
+///        my_locator();
+///        my_locator(const my_locator& pl);
+///
+///        // constructors with dynamic step in y (and x). Only valid for locators with dynamic steps
+///        my_locator(const my_locator& loc, coord_t y_step);
+///        my_locator(const my_locator& loc, coord_t x_step, coord_t y_step, bool transpose);
+///
+///        bool              operator==(const my_locator& p) const;
+///
+///        // return _references_ to horizontal/vertical iterators. Advancing them moves this locator
+///        x_iterator&       x();
+///        y_iterator&       y();
+///        x_iterator const& x() const;
+///        y_iterator const& y() const;
+///
+///        // return the vertical distance to another locator. Some models need the horizontal distance to compute it
+///        y_coord_t         y_distance_to(const my_locator& loc2, x_coord_t xDiff) const;
+///
+///        // return true iff incrementing an x-iterator located at the last column will position it at the first 
+///        // column of the next row. Some models need the image width to determine that.
+///        bool              is_1d_traversable(x_coord_t width) const;
+/// };
+/// \endcode
+///
+/// Models may choose to override some of the functions in the base class with more efficient versions.
+///
+
+template <typename Loc, typename XIterator, typename YIterator>    // The concrete subclass, the X-iterator and the Y-iterator
+class pixel_2d_locator_base {
+public:
+    typedef XIterator           x_iterator;
+    typedef YIterator           y_iterator;
+
+    // typedefs required by ConstRandomAccessNDLocatorConcept
+    static const std::size_t num_dimensions=2;
+    typedef typename std::iterator_traits<x_iterator>::value_type       value_type;
+    typedef typename std::iterator_traits<x_iterator>::reference        reference;    // result of dereferencing
+    typedef typename std::iterator_traits<x_iterator>::difference_type  coord_t;      // 1D difference type (same for all dimensions)
+    typedef point2<coord_t>                                             difference_type; // result of operator-(locator,locator)
+    typedef difference_type                                             point_t;
+    template <std::size_t D> struct axis {
+        typedef typename detail::locator_axis<D,Loc>::coord_t           coord_t;
+        typedef typename detail::locator_axis<D,Loc>::iterator          iterator;
+    };
+
+// typedefs required by ConstRandomAccess2DLocatorConcept
+    typedef typename point_t::template axis<0>::coord_t                 x_coord_t;
+    typedef typename point_t::template axis<1>::coord_t                 y_coord_t;
+
+    bool              operator!=(const Loc& p)          const { return !(concrete()==p); }
+
+    x_iterator        x_at(x_coord_t dx, y_coord_t dy)  const { Loc tmp=concrete(); tmp+=point_t(dx,dy); return tmp.x(); }
+    x_iterator        x_at(const difference_type& d)    const { Loc tmp=concrete(); tmp+=d;              return tmp.x(); }
+    y_iterator        y_at(x_coord_t dx, y_coord_t dy)  const { Loc tmp=concrete(); tmp+=point_t(dx,dy); return tmp.y(); }
+    y_iterator        y_at(const difference_type& d)    const { Loc tmp=concrete(); tmp+=d;              return tmp.y(); }
+    Loc               xy_at(x_coord_t dx, y_coord_t dy) const { Loc tmp=concrete(); tmp+=point_t(dx,dy); return tmp; }
+    Loc               xy_at(const difference_type& d)   const { Loc tmp=concrete(); tmp+=d;              return tmp; }
+
+    template <std::size_t D> typename axis<D>::iterator&       axis_iterator()                       { return detail::locator_axis<D,Loc>()(concrete()); }
+    template <std::size_t D> typename axis<D>::iterator const& axis_iterator()                 const { return detail::locator_axis<D,Loc>()(concrete()); }
+    template <std::size_t D> typename axis<D>::iterator        axis_iterator(const point_t& p) const { return detail::locator_axis<D,Loc>()(concrete(),p); }
+
+    reference         operator()(x_coord_t dx, y_coord_t dy) const { return *x_at(dx,dy); }
+    reference         operator[](const difference_type& d)   const { return *x_at(d.x,d.y); }
+
+    reference         operator*()                            const { return *concrete().x(); }
+
+    Loc&              operator+=(const difference_type& d)         { concrete().x()+=d.x; concrete().y()+=d.y; return concrete(); }
+    Loc&              operator-=(const difference_type& d)         { concrete().x()-=d.x; concrete().y()-=d.y; return concrete(); }
+    
+    Loc               operator+(const difference_type& d)    const { return xy_at(d); }
+    Loc               operator-(const difference_type& d)    const { return xy_at(-d); }
+
+    // Some locators can cache 2D coordinates for faster subsequent access. By default there is no caching
+    typedef difference_type    cached_location_t;    
+    cached_location_t cache_location(const difference_type& d)  const { return d; }
+    cached_location_t cache_location(x_coord_t dx, y_coord_t dy)const { return difference_type(dx,dy); }
+
+private:
+    Loc&              concrete()       { return (Loc&)*this; }
+    const Loc&        concrete() const { return (const Loc&)*this; }
+
+    template <typename X> friend class pixel_2d_locator;
+};
+
+// helper classes for each axis of pixel_2d_locator_base
+namespace detail {
+    template <typename Loc> 
+    class locator_axis<0,Loc> {
+        typedef typename Loc::point_t                       point_t;
+    public:
+        typedef typename point_t::template axis<0>::coord_t coord_t;
+        typedef typename Loc::x_iterator                    iterator;
+
+        inline iterator&        operator()(      Loc& loc)                   const { return loc.x(); }
+        inline iterator  const& operator()(const Loc& loc)                   const { return loc.x(); }
+        inline iterator         operator()(      Loc& loc, const point_t& d) const { return loc.x_at(d); }
+        inline iterator         operator()(const Loc& loc, const point_t& d) const { return loc.x_at(d); }
+    };
+
+    template <typename Loc> 
+    class locator_axis<1,Loc> {
+        typedef typename Loc::point_t                       point_t;
+    public:
+        typedef typename point_t::template axis<1>::coord_t coord_t;
+        typedef typename Loc::y_iterator                    iterator;
+
+        inline iterator&        operator()(      Loc& loc)               const { return loc.y(); }
+        inline iterator const&  operator()(const Loc& loc)               const { return loc.y(); }
+        inline iterator     operator()(      Loc& loc, const point_t& d) const { return loc.y_at(d); }
+        inline iterator     operator()(const Loc& loc, const point_t& d) const { return loc.y_at(d); }
+    };
+}
+
+template <typename Loc, typename XIt, typename YIt>
+struct channel_type<pixel_2d_locator_base<Loc,XIt,YIt> > : public channel_type<XIt> {};
+
+template <typename Loc, typename XIt, typename YIt>
+struct color_space_type<pixel_2d_locator_base<Loc,XIt,YIt> > : public color_space_type<XIt> {};
+
+template <typename Loc, typename XIt, typename YIt>
+struct channel_mapping_type<pixel_2d_locator_base<Loc,XIt,YIt> > : public channel_mapping_type<XIt> {};
+
+template <typename Loc, typename XIt, typename YIt>
+struct is_planar<pixel_2d_locator_base<Loc,XIt,YIt> > : public is_planar<XIt> {};
+
+/// \class memory_based_2d_locator
+/// \brief Memory-based pixel locator. Models: PixelLocatorConcept,HasDynamicXStepTypeConcept,HasDynamicYStepTypeConcept,HasTransposedTypeConcept
+/// \ingroup PixelLocatorModel PixelBasedModel
+///
+/// The class takes a step iterator as a parameter. The step iterator provides navigation along the vertical axis
+/// while its base iterator provides horizontal navigation.
+///
+/// Each instantiation is optimal in terms of size and efficiency.
+/// For example, xy locator over interleaved rgb image results in a step iterator consisting of 
+/// one std::ptrdiff_t for the row size and one native pointer (8 bytes total). ++locator.x() resolves to pointer 
+/// increment. At the other extreme, a 2D navigation of the even pixels of a planar CMYK image results in a step 
+/// iterator consisting of one std::ptrdiff_t for the doubled row size, and one step iterator consisting of 
+/// one std::ptrdiff_t for the horizontal step of two and a CMYK planar_pixel_iterator consisting of 4 pointers (24 bytes).
+/// In this case ++locator.x() results in four native pointer additions.
+///
+/// Note also that \p memory_based_2d_locator does not require that its element type be a pixel. It could be
+/// instantiated with an iterator whose \p value_type models only \p Regular. In this case the locator
+/// models the weaker RandomAccess2DLocatorConcept, and does not model PixelBasedConcept.
+/// Many generic algorithms don't require the elements to be pixels.
+////////////////////////////////////////////////////////////////////////////////////////
+
+template <typename StepIterator>
+class memory_based_2d_locator : public pixel_2d_locator_base<memory_based_2d_locator<StepIterator>, typename iterator_adaptor_get_base<StepIterator>::type, StepIterator> {
+    typedef memory_based_2d_locator<StepIterator>  this_t;
+    GIL_CLASS_REQUIRE(StepIterator, boost::gil, StepIteratorConcept)
+public:
+    typedef pixel_2d_locator_base<memory_based_2d_locator<StepIterator>, typename iterator_adaptor_get_base<StepIterator>::type, StepIterator> parent_t;
+    typedef memory_based_2d_locator<typename const_iterator_type<StepIterator>::type> const_t; // same as this type, but over const values
+
+    typedef typename parent_t::coord_t          coord_t;
+    typedef typename parent_t::x_coord_t        x_coord_t;
+    typedef typename parent_t::y_coord_t        y_coord_t;
+    typedef typename parent_t::x_iterator       x_iterator;
+    typedef typename parent_t::y_iterator       y_iterator;
+    typedef typename parent_t::difference_type  difference_type;
+    typedef typename parent_t::reference        reference;
+
+    template <typename Deref> struct add_deref {
+        typedef memory_based_2d_locator<typename iterator_add_deref<StepIterator,Deref>::type> type;
+        static type make(const memory_based_2d_locator<StepIterator>& loc, const Deref& nderef) { 
+            return type(iterator_add_deref<StepIterator,Deref>::make(loc.y(),nderef)); 
+        }
+    };
+
+    memory_based_2d_locator() {}
+    memory_based_2d_locator(const StepIterator& yit) : _p(yit) {}
+    template <typename SI> memory_based_2d_locator(const memory_based_2d_locator<SI>& loc, coord_t y_step) : _p(loc.x(), loc.row_size()*y_step) {}
+    template <typename SI> memory_based_2d_locator(const memory_based_2d_locator<SI>& loc, coord_t x_step, coord_t y_step, bool transpose=false)
+        : _p(make_step_iterator(loc.x(),(transpose ? loc.row_size() : loc.pixel_size())*x_step),
+                                        (transpose ? loc.pixel_size() : loc.row_size())*y_step ) {}
+
+    memory_based_2d_locator(x_iterator xit, std::ptrdiff_t row_bytes) : _p(xit,row_bytes) {}
+    template <typename X> memory_based_2d_locator(const memory_based_2d_locator<X>& pl) : _p(pl._p) {}
+    memory_based_2d_locator(const memory_based_2d_locator& pl) : _p(pl._p) {}
+
+    bool                  operator==(const this_t& p)  const { return _p==p._p; }
+
+    x_iterator const&     x()                          const { return _p.base(); }
+    y_iterator const&     y()                          const { return _p; }
+    x_iterator&           x()                                { return _p.base(); }
+    y_iterator&           y()                                { return _p; }
+
+    // These are faster versions of functions already provided in the superclass 
+    x_iterator x_at      (x_coord_t dx, y_coord_t dy)  const { return memunit_advanced(x(), offset(dx,dy)); }    
+    x_iterator x_at      (const difference_type& d)    const { return memunit_advanced(x(), offset(d.x,d.y)); }
+    this_t     xy_at     (x_coord_t dx, y_coord_t dy)  const { return this_t(x_at( dx , dy ), row_size()); }
+    this_t     xy_at     (const difference_type& d)    const { return this_t(x_at( d.x, d.y), row_size()); }
+    reference  operator()(x_coord_t dx, y_coord_t dy)  const { return memunit_advanced_ref(x(),offset(dx,dy)); }
+    reference  operator[](const difference_type& d)    const { return memunit_advanced_ref(x(),offset(d.x,d.y)); }
+    this_t&    operator+=(const difference_type& d)          { memunit_advance(x(),offset(d.x,d.y)); return *this; }
+    this_t&    operator-=(const difference_type& d)          { memunit_advance(x(),offset(-d.x,-d.y)); return *this; }
+
+    // Memory-based locators can have 1D caching of 2D relative coordinates
+    typedef std::ptrdiff_t cached_location_t; // type used to store relative location (to allow for more efficient repeated access)
+    cached_location_t cache_location(const difference_type& d)  const { return offset(d.x,d.y); }
+    cached_location_t cache_location(x_coord_t dx, y_coord_t dy)const { return offset(dx,dy); }
+    reference         operator[](const cached_location_t& loc)  const { return memunit_advanced_ref(x(),loc); }
+
+    // Only make sense for memory-based locators
+    std::ptrdiff_t         row_size()                           const { return memunit_step(y()); }    // distance in mem units (bytes or bits) between adjacent rows
+    std::ptrdiff_t         pixel_size()                         const { return memunit_step(x()); }    // distance in mem units (bytes or bits) between adjacent pixels on the same row
+
+    //bool                   is_1d_traversable(x_coord_t width)   const { return row_size()-pixel_size()*width==0; }   // is there no gap at the end of each row?
+    bool                   is_1d_traversable( x_coord_t const width )   const
+    {
+        /// \todo The ** case might not be safe for algorithms that expect an
+        /// exact number of elements/iterations or are not stable for all input
+        /// values (that might happen at the padding tail at the end of rows) so
+        /// this must be reconsidered and reimplemented.
+        ///                                   (10.10.2010.) (Domagoj Saric)
+        bool const compile_time_detection
+        (
+            ( pixel_size()                    == 1 ) ||
+            ( pixel_size() % sizeof( void * ) == 0 ) ||
+            ( // ...**...
+                ( pixel_size() % 2 == 0                ) &&
+                ( pixel_size()      < sizeof( void * ) )
+            )
+        );
+
+        // Use unsigned division and use 32/16 division to avoid the
+        // unnecessary cdq x86 instruction.
+        //( static_cast<unsigned int>( row_size() * 8 ) % static_cast<unsigned short>( pixel_size() * 8 ) == 0 )
+        bool const run_time_detection
+        (
+            (
+                static_cast<unsigned int  >( row_size  () )
+                    -
+                static_cast<unsigned short>( pixel_size() )
+                    *
+                static_cast<unsigned int  >( width        )
+            ) == 0
+        );
+
+        return compile_time_detection || run_time_detection;
+    }
+
+    // Returns the vertical distance (it2.y-it1.y) between two x_iterators given the difference of their x positions
+    std::ptrdiff_t y_distance_to(const this_t& p2, x_coord_t xDiff) const { 
+        std::ptrdiff_t rowDiff=memunit_distance(x(),p2.x())-pixel_size()*xDiff;
+        assert(( rowDiff % row_size())==0);
+        return rowDiff / row_size();
+    }
+
+private:
+    template <typename X> friend class memory_based_2d_locator;
+    std::ptrdiff_t offset(x_coord_t x, y_coord_t y)        const { return y*row_size() + x*pixel_size(); }
+    StepIterator _p;
+};
+
+/////////////////////////////
+//  PixelBasedConcept
+/////////////////////////////
+
+template <typename SI>
+struct color_space_type<memory_based_2d_locator<SI> > : public color_space_type<typename memory_based_2d_locator<SI>::parent_t> {
+};
+
+template <typename SI>
+struct channel_mapping_type<memory_based_2d_locator<SI> > : public channel_mapping_type<typename memory_based_2d_locator<SI>::parent_t> {
+};
+
+template <typename SI>
+struct is_planar<memory_based_2d_locator<SI> > : public is_planar<typename memory_based_2d_locator<SI>::parent_t> {
+};
+
+template <typename SI>
+struct channel_type<memory_based_2d_locator<SI> > : public channel_type<typename memory_based_2d_locator<SI>::parent_t> {
+};
+
+/////////////////////////////
+//  HasDynamicXStepTypeConcept
+/////////////////////////////
+
+// Take the base iterator of SI (which is typically a step iterator) and change it to have a step in x
+template <typename SI>
+struct dynamic_x_step_type<memory_based_2d_locator<SI> > {
+private:
+    typedef typename iterator_adaptor_get_base<SI>::type                        base_iterator_t;
+    typedef typename dynamic_x_step_type<base_iterator_t>::type                 base_iterator_step_t;
+    typedef typename iterator_adaptor_rebind<SI, base_iterator_step_t>::type    dynamic_step_base_t;
+public:
+    typedef memory_based_2d_locator<dynamic_step_base_t> type;
+};
+
+/////////////////////////////
+//  HasDynamicYStepTypeConcept
+/////////////////////////////
+
+template <typename SI>
+struct dynamic_y_step_type<memory_based_2d_locator<SI> > {
+    typedef memory_based_2d_locator<SI> type;
+};
+
+} }  // namespace boost::gil
+
+#endif

Added: sandbox/gil/boost/gil/utilities.hpp
==============================================================================
--- (empty file)
+++ sandbox/gil/boost/gil/utilities.hpp	2010-10-10 12:42:02 EDT (Sun, 10 Oct 2010)
@@ -0,0 +1,333 @@
+/*
+    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_UTILITIES_H
+#define GIL_UTILITIES_H
+
+#include "gil_config.hpp"
+#include <functional>
+#include <boost/config/no_tr1/cmath.hpp>
+#include <cstddef>
+#include <algorithm>
+#include <utility>
+#include <iterator>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits.hpp>
+#include <boost/mpl/size.hpp>
+#include <boost/mpl/distance.hpp>
+#include <boost/mpl/begin.hpp>
+#include <boost/mpl/find.hpp>
+#include <boost/mpl/range_c.hpp>
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/iterator_facade.hpp>
+
+////////////////////////////////////////////////////////////////////////////////////////
+/// \file               
+/// \brief  Various utilities not specific to the image library. Some are non-standard STL extensions or generic iterator adaptors
+/// \author Lubomir Bourdev and Hailin Jin \n
+///         Adobe Systems Incorporated
+/// \date   2005-2007 \n Last updated on September 18, 2007
+///
+///
+////////////////////////////////////////////////////////////////////////////////////////
+
+namespace boost { namespace gil {
+
+/**
+\addtogroup PointModel
+
+Example:
+\code
+point2<std::ptrdiff_t> p(3,2);
+assert((p[0] == p.x) && (p[1] == p.y));
+assert(axis_value<0>(p) == 3);
+assert(axis_value<1>(p) == 2);
+\endcode
+*/
+
+////////////////////////////////////////////////////////////////////////////////////////
+//                           CLASS point2
+///
+/// \brief 2D point both axes of which have the same dimension type
+/// \ingroup PointModel
+/// Models: Point2DConcept
+///
+////////////////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+class point2 {
+public:
+    typedef T value_type;
+    template <std::size_t D> struct axis { typedef value_type coord_t; };
+    static const std::size_t num_dimensions=2;
+
+    point2()                : x(0),     y(0)    {}
+    point2(T newX, T newY)  : x(newX),  y(newY) {}
+    point2(const point2& p) : x(p.x), y(p.y) {}
+    #ifndef BOOST_MSVC
+        ~point2() {} // This creates (fake) EH states which bug the MSVC++ optimizer...
+    #endif // BOOST_MSVC
+
+    point2& operator=(const point2& p)            { x=p.x; y=p.y; return *this; }
+
+    point2        operator<<(std::ptrdiff_t shift)         const   { return point2(x<<shift,y<<shift); }
+    point2        operator>>(std::ptrdiff_t shift)         const   { return point2(x>>shift,y>>shift); }
+    point2& operator+=(const point2& p)           { x+=p.x; y+=p.y; return *this; }
+    point2& operator-=(const point2& p)           { x-=p.x; y-=p.y; return *this; }
+    point2& operator/=(double t)                  { x/=t; y/=t; return *this; }
+
+    const T& operator[](std::size_t i)          const   { return this->*mem_array[i]; }
+          T& operator[](std::size_t i)                  { return this->*mem_array[i]; }
+
+    T x,y;
+private:
+    // this static array of pointers to member variables makes operator[] safe and doesn't seem to exhibit any performance penalty
+    static T point2<T>::* const mem_array[num_dimensions];
+};
+
+template <typename T>
+T point2<T>::* const point2<T>::mem_array[point2<T>::num_dimensions] = { &point2<T>::x, &point2<T>::y };
+
+/// \ingroup PointModel
+template <typename T> GIL_FORCEINLINE
+bool operator==(const point2<T>& p1, const point2<T>& p2) { return (p1.x==p2.x && p1.y==p2.y); }
+/// \ingroup PointModel
+template <typename T> GIL_FORCEINLINE
+bool operator!=(const point2<T>& p1, const point2<T>& p2) { return  p1.x!=p2.x || p1.y!=p2.y; }
+/// \ingroup PointModel
+template <typename T> GIL_FORCEINLINE
+point2<T> operator+(const point2<T>& p1, const point2<T>& p2) { return point2<T>(p1.x+p2.x,p1.y+p2.y); }
+/// \ingroup PointModel
+template <typename T> GIL_FORCEINLINE
+point2<T> operator-(const point2<T>& p) { return point2<T>(-p.x,-p.y); }
+/// \ingroup PointModel
+template <typename T> GIL_FORCEINLINE
+point2<T> operator-(const point2<T>& p1, const point2<T>& p2) { return point2<T>(p1.x-p2.x,p1.y-p2.y); }
+/// \ingroup PointModel
+template <typename T> GIL_FORCEINLINE
+point2<double> operator/(const point2<T>& p, double t)      { return t==0 ? point2<double>(0,0):point2<double>(p.x/t,p.y/t); }
+/// \ingroup PointModel
+template <typename T> GIL_FORCEINLINE
+point2<T> operator*(const point2<T>& p, std::ptrdiff_t t)      { return point2<T>(p.x*t,p.y*t); }
+/// \ingroup PointModel
+template <typename T> GIL_FORCEINLINE
+point2<T> operator*(std::ptrdiff_t t, const point2<T>& p)      { return point2<T>(p.x*t,p.y*t); }
+
+/// \ingroup PointModel
+template <std::size_t K, typename T> GIL_FORCEINLINE
+const T& axis_value(const point2<T>& p) { return p[K]; }
+
+/// \ingroup PointModel
+template <std::size_t K, typename T> GIL_FORCEINLINE
+      T& axis_value(      point2<T>& p) { return p[K]; }
+
+////////////////////////////////////////////////////////////////////////////////////////
+///
+///  Rounding of real numbers / points to integers / integer points
+///
+////////////////////////////////////////////////////////////////////////////////////////
+
+inline std::ptrdiff_t iround(float x ) { return static_cast<std::ptrdiff_t>(x + (x < 0.0f ? -0.5f : 0.5f)); }
+inline std::ptrdiff_t iround(double x) { return static_cast<std::ptrdiff_t>(x + (x < 0.0 ? -0.5 : 0.5)); }
+inline std::ptrdiff_t ifloor(float x ) { return static_cast<std::ptrdiff_t>(std::floor(x)); }
+inline std::ptrdiff_t ifloor(double x) { return static_cast<std::ptrdiff_t>(std::floor(x)); }
+inline std::ptrdiff_t iceil(float x )  { return static_cast<std::ptrdiff_t>(std::ceil(x)); }
+inline std::ptrdiff_t iceil(double x)  { return static_cast<std::ptrdiff_t>(std::ceil(x)); }
+
+/**
+\addtogroup PointAlgorithm
+
+Example:
+\code
+assert(iround(point2<double>(3.1, 3.9)) == point2<std::ptrdiff_t>(3,4));
+\endcode
+*/
+
+/// \ingroup PointAlgorithm
+inline point2<std::ptrdiff_t> iround(const point2<float >& p)  { return point2<std::ptrdiff_t>(iround(p.x),iround(p.y)); }
+/// \ingroup PointAlgorithm
+inline point2<std::ptrdiff_t> iround(const point2<double>& p)  { return point2<std::ptrdiff_t>(iround(p.x),iround(p.y)); }
+/// \ingroup PointAlgorithm
+inline point2<std::ptrdiff_t> ifloor(const point2<float >& p)  { return point2<std::ptrdiff_t>(ifloor(p.x),ifloor(p.y)); }
+/// \ingroup PointAlgorithm
+inline point2<std::ptrdiff_t> ifloor(const point2<double>& p)  { return point2<std::ptrdiff_t>(ifloor(p.x),ifloor(p.y)); }
+/// \ingroup PointAlgorithm
+inline point2<std::ptrdiff_t> iceil (const point2<float >& p)  { return point2<std::ptrdiff_t>(iceil(p.x), iceil(p.y)); }
+/// \ingroup PointAlgorithm
+inline point2<std::ptrdiff_t> iceil (const point2<double>& p)  { return point2<std::ptrdiff_t>(iceil(p.x), iceil(p.y)); }
+
+////////////////////////////////////////////////////////////////////////////////////////
+///
+///  computing size with alignment
+///
+////////////////////////////////////////////////////////////////////////////////////////
+
+template <typename T> 
+inline T align(T val, std::size_t alignment) { 
+    return val+(alignment - val%alignment)%alignment; 
+}
+
+/// \brief Helper base class for pixel dereference adaptors. 
+/// \ingroup PixelDereferenceAdaptorModel
+///
+template <typename ConstT, typename Value, typename Reference, typename ConstReference,
+          typename ArgType, typename ResultType, bool IsMutable>
+struct deref_base : public std::unary_function<ArgType, ResultType> {
+    typedef ConstT         const_t;
+    typedef Value          value_type;
+    typedef Reference      reference;
+    typedef ConstReference const_reference;
+    BOOST_STATIC_CONSTANT(bool, is_mutable = IsMutable);
+};
+
+/// \brief Composes two dereference function objects. Similar to std::unary_compose but needs to pull some typedefs from the component types.  Models: PixelDereferenceAdaptorConcept
+/// \ingroup PixelDereferenceAdaptorModel
+///
+template <typename D1, typename D2>
+class deref_compose : public deref_base<
+      deref_compose<typename D1::const_t, typename D2::const_t>,
+      typename D1::value_type, typename D1::reference, typename D1::const_reference, 
+      typename D2::argument_type, typename D1::result_type, D1::is_mutable && D2::is_mutable>
+{
+public:
+    D1 _fn1;
+    D2 _fn2;
+
+    typedef typename D2::argument_type   argument_type;
+    typedef typename D1::result_type     result_type;
+
+    deref_compose() {}
+    deref_compose(const D1& x, const D2& y) : _fn1(x), _fn2(y) {}
+    deref_compose(const deref_compose& dc)  : _fn1(dc._fn1), _fn2(dc._fn2) {}
+    template <typename _D1, typename _D2> deref_compose(const deref_compose<_D1,_D2>& dc) : _fn1(dc._fn1), _fn2(dc._fn2) {}
+
+    result_type operator()(argument_type x) const { return _fn1(_fn2(x)); }
+    result_type operator()(argument_type x)       { return _fn1(_fn2(x)); }
+};
+
+// reinterpret_cast is implementation-defined. Static cast is not.
+template <typename OutPtr, typename In> GIL_FORCEINLINE
+      OutPtr gil_reinterpret_cast(      In* p) { return static_cast<OutPtr>(static_cast<void*>(p)); }
+
+template <typename OutPtr, typename In> GIL_FORCEINLINE
+const OutPtr gil_reinterpret_cast_c(const In* p) { return static_cast<const OutPtr>(static_cast<const void*>(p)); }
+
+namespace detail {
+
+////////////////////////////////////////////////////////////////////////////////////////
+///
+///  \brief copy_n taken from SGI STL.
+///
+////////////////////////////////////////////////////////////////////////////////////////
+
+template <class InputIter, class Size, class OutputIter>
+std::pair<InputIter, OutputIter> _copy_n(InputIter first, Size count,
+                                         OutputIter result,
+                                         std::input_iterator_tag) {
+   for ( ; count > 0; --count) {
+      *result = *first;
+      ++first;
+      ++result;
+   }
+   return std::pair<InputIter, OutputIter>(first, result);
+}
+
+template <class RAIter, class Size, class OutputIter>
+inline std::pair<RAIter, OutputIter>
+_copy_n(RAIter first, Size count, OutputIter result, std::random_access_iterator_tag) {
+   RAIter last = first + count;
+   return std::pair<RAIter, OutputIter>(last, std::copy(first, last, result));
+}
+
+template <class InputIter, class Size, class OutputIter>
+inline std::pair<InputIter, OutputIter>
+_copy_n(InputIter first, Size count, OutputIter result) {
+   return _copy_n(first, count, result, typename std::iterator_traits<InputIter>::iterator_category());
+}
+
+template <class InputIter, class Size, class OutputIter>
+inline std::pair<InputIter, OutputIter>
+copy_n(InputIter first, Size count, OutputIter result) {
+    return detail::_copy_n(first, count, result);
+}
+
+/// \brief identity taken from SGI STL.
+template <typename T> 
+struct identity : public std::unary_function<T,T> {
+    const T& operator()(const T& val) const { return val; }
+};
+
+/*************************************************************************************************/
+
+/// \brief plus function object whose arguments may be of different type.
+template <typename T1, typename T2>
+struct plus_asymmetric : public std::binary_function<T1,T2,T1> {
+    T1 operator()(T1 f1, T2 f2) const {
+        return f1+f2;
+    }
+};
+
+/*************************************************************************************************/
+
+/// \brief operator++ wrapped in a function object
+template <typename T>
+struct inc : public std::unary_function<T,T> {
+    T operator()(T x) const { return ++x; }
+};
+
+/*************************************************************************************************/
+
+/// \brief operator-- wrapped in a function object
+template <typename T>
+struct dec : public std::unary_function<T,T> {
+    T operator()(T x) const { return --x; }
+};
+
+/// \brief Returns the index corresponding to the first occurrance of a given given type in 
+//         a given MPL RandomAccessSequence (or size if the type is not present)
+template <typename Types, typename T>
+struct type_to_index 
+    : public mpl::distance<typename mpl::begin<Types>::type, 
+                                  typename mpl::find<Types,T>::type>::type {};
+} // namespace detail
+
+
+
+/// \ingroup ColorSpaceAndLayoutModel
+/// \brief Represents a color space and ordering of channels in memory
+template <typename ColorSpace, typename ChannelMapping = mpl::range_c<int,0,mpl::size<ColorSpace>::value> >
+struct layout {
+    typedef ColorSpace      color_space_t;
+    typedef ChannelMapping  channel_mapping_t;
+};
+
+/// \brief A version of swap that also works with reference proxy objects
+template <typename Value, typename T1, typename T2> // where value_type<T1>  == value_type<T2> == Value
+void swap_proxy(T1& left, T2& right) {
+    Value tmp = left;
+    left = right;
+    right = tmp;
+}
+
+/// \brief Run-time detection of whether the underlying architecture is little endian
+inline bool little_endian() {
+    short tester = 0x0001;
+    return  *(char*)&tester!=0;
+}
+/// \brief Run-time detection of whether the underlying architecture is big endian
+inline bool big_endian() {
+    return !little_endian();
+}
+
+} }  // namespace boost::gil
+
+#endif