diff --git a/develop/doc/html/.buildinfo b/develop/doc/html/.buildinfo index f89a81e6c..6ba660a27 100644 --- a/develop/doc/html/.buildinfo +++ b/develop/doc/html/.buildinfo @@ -1,4 +1,4 @@ # Sphinx build info version 1 # This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done. -config: 79eaa9b23466b1406dd8a33011d7894a +config: 83bbed787a8fde5047710da3d607efdd tags: 645f666f9bcd5a90fca523b33c5a78b7 diff --git a/develop/doc/html/_static/basic.css b/develop/doc/html/_static/basic.css index 2e3cf3230..24bc73e7f 100644 --- a/develop/doc/html/_static/basic.css +++ b/develop/doc/html/_static/basic.css @@ -693,7 +693,7 @@ pre { overflow-y: hidden; /* fixes display issues on Chrome browsers */ } -pre, div[class|="highlight"] { +pre, div[class*="highlight-"] { clear: both; } @@ -704,7 +704,7 @@ span.pre { hyphens: none; } -div[class^="highlight-"] { +div[class*="highlight-"] { margin: 1em 0; } diff --git a/develop/doc/html/_static/pygments.css b/develop/doc/html/_static/pygments.css index 631bc92ff..be9feffb7 100644 --- a/develop/doc/html/_static/pygments.css +++ b/develop/doc/html/_static/pygments.css @@ -1,5 +1,10 @@ +pre { line-height: 125%; margin: 0; } +td.linenos pre { color: #000000; background-color: #f0f0f0; padding: 0 5px 0 5px; } +span.linenos { color: #000000; background-color: #f0f0f0; padding: 0 5px 0 5px; } +td.linenos pre.special { color: #000000; background-color: #ffffc0; padding: 0 5px 0 5px; } +span.linenos.special { color: #000000; background-color: #ffffc0; padding: 0 5px 0 5px; } .highlight .hll { background-color: #ffffcc } -.highlight { background: #f8f8f8; } +.highlight { background: #f8f8f8; } .highlight .c { color: #408080; font-style: italic } /* Comment */ .highlight .err { border: 1px solid #FF0000 } /* Error */ .highlight .k { color: #008000; font-weight: bold } /* Keyword */ diff --git a/develop/doc/html/_static/searchtools.js b/develop/doc/html/_static/searchtools.js index ab5649965..970d0d975 100644 --- a/develop/doc/html/_static/searchtools.js +++ b/develop/doc/html/_static/searchtools.js @@ -166,8 +166,7 @@ var Search = { objectterms.push(tmp[i].toLowerCase()); } - if ($u.indexOf(stopwords, tmp[i].toLowerCase()) != -1 || tmp[i].match(/^\d+$/) || - tmp[i] === "") { + if ($u.indexOf(stopwords, tmp[i].toLowerCase()) != -1 || tmp[i] === "") { // skip this "word" continue; } diff --git a/develop/doc/html/design/basics.html b/develop/doc/html/design/basics.html index 63f998c2a..a4c9b17e1 100644 --- a/develop/doc/html/design/basics.html +++ b/develop/doc/html/design/basics.html @@ -114,8 +114,8 @@ read the sections in order.

\ No newline at end of file diff --git a/develop/doc/html/design/channel.html b/develop/doc/html/design/channel.html index 191b47236..77f3597b5 100644 --- a/develop/doc/html/design/channel.html +++ b/develop/doc/html/design/channel.html @@ -81,30 +81,30 @@ channel in an RGB pixel). Typical channel operations are getting, comparing and setting the channel values. Channels have associated minimum and maximum value. GIL channels model the following concept:

-
concept ChannelConcept<typename T> : EqualityComparable<T>
+
concept ChannelConcept<typename T> : EqualityComparable<T>
 {
-    typename value_type      = T;        // use channel_traits<T>::value_type to access it
+    typename value_type      = T;        // use channel_traits<T>::value_type to access it
     where ChannelValueConcept<value_type>;
-    typename reference       = T&;       // use channel_traits<T>::reference to access it
-    typename pointer         = T*;       // use channel_traits<T>::pointer to access it
-    typename const_reference = const T&; // use channel_traits<T>::const_reference to access it
-    typename const_pointer   = const T*; // use channel_traits<T>::const_pointer to access it
+    typename reference       = T&;       // use channel_traits<T>::reference to access it
+    typename pointer         = T*;       // use channel_traits<T>::pointer to access it
+    typename const_reference = const T&; // use channel_traits<T>::const_reference to access it
+    typename const_pointer   = const T*; // use channel_traits<T>::const_pointer to access it
     static const bool is_mutable;        // use channel_traits<T>::is_mutable to access it
 
-    static T min_value();                // use channel_traits<T>::min_value to access it
-    static T max_value();                // use channel_traits<T>::min_value to access it
+    static T min_value();                // use channel_traits<T>::min_value to access it
+    static T max_value();                // use channel_traits<T>::min_value to access it
 };
 
-concept MutableChannelConcept<ChannelConcept T> : Swappable<T>, Assignable<T> {};
+concept MutableChannelConcept<ChannelConcept T> : Swappable<T>, Assignable<T> {};
 
-concept ChannelValueConcept<ChannelConcept T> : Regular<T> {};
+concept ChannelValueConcept<ChannelConcept T> : Regular<T> {};
 

 

 
GIL allows built-in integral and floating point types to be channels.
 Therefore the associated types and range information are defined in
 channel_traits with the following default implementation:

-
template <typename T>
-struct channel_traits
+
template <typename T>
+struct channel_traits
 {
     typedef T         value_type;
     typedef T&        reference;
@@ -112,13 +112,13 @@ Therefore the associated types and range information are defined in
     typedef T& const  const_reference;
     typedef T* const  const_pointer;
 
-    static value_type min_value() { return std::numeric_limits<T>::min(); }
-    static value_type max_value() { return std::numeric_limits<T>::max(); }
+    static value_type min_value() { return std::numeric_limits<T>::min(); }
+    static value_type max_value() { return std::numeric_limits<T>::max(); }
 };
 

 

 
Two channel types are compatible if they have the same value type:

-
concept ChannelsCompatibleConcept<ChannelConcept T1, ChannelConcept T2>
+
concept ChannelsCompatibleConcept<ChannelConcept T1, ChannelConcept T2>
 {
     where SameType<T1::value_type, T2::value_type>;
 };
@@ -126,9 +126,9 @@ Therefore the associated types and range information are defined in
 

 
A channel may be convertible to another channel:

 
template <ChannelConcept Src, ChannelValueConcept Dst>
-concept ChannelConvertibleConcept
+concept ChannelConvertibleConcept
 {
-    Dst channel_convert(Src);
+    Dst channel_convert(Src);
 };
 

 

@@ -163,8 +163,8 @@ specified by its st
 appropriate. GIL provides scoped_channel_value, a model for a channel
 adapter that allows for specifying a custom range.
 We use it to define a [0..1] floating point channel type as follows:

-
struct float_zero { static float apply() { return 0.0f; } };
-struct float_one  { static float apply() { return 1.0f; } };
+
struct float_zero { static float apply() { return 0.0f; } };
+struct float_one  { static float apply() { return 1.0f; } };
 typedef scoped_channel_value<float,float_zero,float_one> bits32f;
 

 

@@ -237,16 +237,16 @@ floating point type. Thus they support arithmetic operations. Here are the
 channel-level algorithms that GIL provides:

 
// Converts a source channel value into a destination channel.
 // Linearly maps the value of the source into the range of the destination.
-template <typename DstChannel, typename SrcChannel>
-typename channel_traits<DstChannel>::value_type channel_convert(SrcChannel src);
+template <typename DstChannel, typename SrcChannel>
+typename channel_traits<DstChannel>::value_type channel_convert(SrcChannel src);
 
 // returns max_value - x + min_value
-template <typename Channel>
-typename channel_traits<Channel>::value_type channel_invert(Channel x);
+template <typename Channel>
+typename channel_traits<Channel>::value_type channel_invert(Channel x);
 
 // returns a * b / max_value
-template <typename Channel>
-typename channel_traits<Channel>::value_type channel_multiply(Channel a, Channel b);
+template <typename Channel>
+typename channel_traits<Channel>::value_type channel_multiply(Channel a, Channel b);
 

 

 

@@ -263,8 +263,8 @@ channel-level algorithms that GIL provides:

     

     

     
   
 
\ No newline at end of file
diff --git a/develop/doc/html/design/color_base.html b/develop/doc/html/design/color_base.html
index b6e178a8a..c710b9ad5 100644
--- a/develop/doc/html/design/color_base.html
+++ b/develop/doc/html/design/color_base.html
@@ -85,18 +85,18 @@ memory. Its reference is a proxy class that uses a color base whose elements
 are channel references. Its iterator uses a color base whose elements are
 channel iterators.

 
Color base models must satisfy the following concepts:

-
concept ColorBaseConcept<typename T>
+
concept ColorBaseConcept<typename T>
     : CopyConstructible<T>, EqualityComparable<T>
 {
   // a GIL layout (the color space and element permutation)
-  typename layout_t;
+  typename layout_t;
 
   // The type of K-th element
-  template <int K> struct kth_element_type;
+  template <int K> struct kth_element_type;
       where Metafunction<kth_element_type>;
 
   // The result of at_c
-  template <int K> struct kth_element_const_reference_type;
+  template <int K> struct kth_element_const_reference_type;
       where Metafunction<kth_element_const_reference_type>;
 
   template <int K> kth_element_const_reference_type<T,K>::type at_c(T);
@@ -110,10 +110,10 @@ channel iterators.

 
 };
 
-concept MutableColorBaseConcept<ColorBaseConcept T>
+concept MutableColorBaseConcept<ColorBaseConcept T>
     : Assignable<T>, Swappable<T>
 {
-  template <int K> struct kth_element_reference_type;
+  template <int K> struct kth_element_reference_type;
       where Metafunction<kth_element_reference_type>;
 
   template <int K> kth_element_reference_type<T,K>::type at_c(T);
@@ -122,29 +122,29 @@ channel iterators.

       T& operator=(T&, const T2&);
 };
 
-concept ColorBaseValueConcept<typename T> : MutableColorBaseConcept<T>, Regular<T>
+concept ColorBaseValueConcept<typename T> : MutableColorBaseConcept<T>, Regular<T>
 {
 };
 
-concept HomogeneousColorBaseConcept<ColorBaseConcept CB>
+concept HomogeneousColorBaseConcept<ColorBaseConcept CB>
 {
   // For all K in [0 ... size<C1>::value-1):
   //     where SameType<kth_element_type<K>::type, kth_element_type<K+1>::type>;
   kth_element_const_reference_type<0>::type dynamic_at_c(const CB&, std::size_t n) const;
 };
 
-concept MutableHomogeneousColorBaseConcept<MutableColorBaseConcept CB>
+concept MutableHomogeneousColorBaseConcept<MutableColorBaseConcept CB>
     : HomogeneousColorBaseConcept<CB>
 {
   kth_element_reference_type<0>::type dynamic_at_c(const CB&, std::size_t n);
 };
 
-concept HomogeneousColorBaseValueConcept<typename T>
+concept HomogeneousColorBaseValueConcept<typename T>
     : MutableHomogeneousColorBaseConcept<T>, Regular<T>
 {
 };
 
-concept ColorBasesCompatibleConcept<ColorBaseConcept C1, ColorBaseConcept C2>
+concept ColorBasesCompatibleConcept<ColorBaseConcept C1, ColorBaseConcept C2>
 {
   where SameType<C1::layout_t::color_space_t, C2::layout_t::color_space_t>;
   // also, for all K in [0 ... size<C1>::value):
@@ -175,8 +175,8 @@ elements (paired semantically) are convertible to each other.

 all have the same type).

 
namespace detail
 {
-  template <typename Element, typename Layout, int K>
-  struct homogeneous_color_base;
+  template <typename Element, typename Layout, int K>
+  struct homogeneous_color_base;
 }
 

 

@@ -190,74 +190,74 @@ planar pixel iterator. Another model of 
// Metafunction returning an mpl::int_ equal to the number of elements in the color base
-template <class ColorBase> struct size;
+template <class ColorBase> struct size;
 
 // Returns the type of the return value of semantic_at_c<K>(color_base)
-template <class ColorBase, int K> struct kth_semantic_element_reference_type;
-template <class ColorBase, int K> struct kth_semantic_element_const_reference_type;
+template <class ColorBase, int K> struct kth_semantic_element_reference_type;
+template <class ColorBase, int K> struct kth_semantic_element_const_reference_type;
 
 // Returns a reference to the element with K-th semantic index.
 template <class ColorBase, int K>
-typename kth_semantic_element_reference_type<ColorBase,K>::type       semantic_at_c(ColorBase& p)
+typename kth_semantic_element_reference_type<ColorBase,K>::type       semantic_at_c(ColorBase& p)
 template <class ColorBase, int K>
-typename kth_semantic_element_const_reference_type<ColorBase,K>::type semantic_at_c(const ColorBase& p)
+typename kth_semantic_element_const_reference_type<ColorBase,K>::type semantic_at_c(const ColorBase& p)
 
 // Returns the type of the return value of get_color<Color>(color_base)
-template <typename Color, typename ColorBase> struct color_reference_t;
-template <typename Color, typename ColorBase> struct color_const_reference_t;
+template <typename Color, typename ColorBase> struct color_reference_t;
+template <typename Color, typename ColorBase> struct color_const_reference_t;
 
 // Returns a reference to the element corresponding to the given color
-template <typename ColorBase, typename Color>
-typename color_reference_t<Color,ColorBase>::type get_color(ColorBase& cb, Color=Color());
-template <typename ColorBase, typename Color>
-typename color_const_reference_t<Color,ColorBase>::type get_color(const ColorBase& cb, Color=Color());
+template <typename ColorBase, typename Color>
+typename color_reference_t<Color,ColorBase>::type get_color(ColorBase& cb, Color=Color());
+template <typename ColorBase, typename Color>
+typename color_const_reference_t<Color,ColorBase>::type get_color(const ColorBase& cb, Color=Color());
 
 // Returns the element type of the color base. Defined for homogeneous color bases only
-template <typename ColorBase> struct element_type;
-template <typename ColorBase> struct element_reference_type;
-template <typename ColorBase> struct element_const_reference_type;
+template <typename ColorBase> struct element_type;
+template <typename ColorBase> struct element_reference_type;
+template <typename ColorBase> struct element_const_reference_type;
 

 

 
GIL also provides the following algorithms which operate on color bases.
 Note that they all pair the elements semantically:

 
// Equivalents to std::equal, std::copy, std::fill, std::generate
-template <typename CB1,typename CB2>   bool static_equal(const CB1& p1, const CB2& p2);
-template <typename Src,typename Dst>   void static_copy(const Src& src, Dst& dst);
-template <typename CB, typename Op>    void static_generate(CB& dst,Op op);
+template <typename CB1,typename CB2>   bool static_equal(const CB1& p1, const CB2& p2);
+template <typename Src,typename Dst>   void static_copy(const Src& src, Dst& dst);
+template <typename CB, typename Op>    void static_generate(CB& dst,Op op);
 
 // Equivalents to std::transform
-template <typename CB ,             typename Dst,typename Op> Op static_transform(      CB&,Dst&,Op);
-template <typename CB ,             typename Dst,typename Op> Op static_transform(const CB&,Dst&,Op);
-template <typename CB1,typename CB2,typename Dst,typename Op> Op static_transform(      CB1&,      CB2&,Dst&,Op);
-template <typename CB1,typename CB2,typename Dst,typename Op> Op static_transform(const CB1&,      CB2&,Dst&,Op);
-template <typename CB1,typename CB2,typename Dst,typename Op> Op static_transform(      CB1&,const CB2&,Dst&,Op);
-template <typename CB1,typename CB2,typename Dst,typename Op> Op static_transform(const CB1&,const CB2&,Dst&,Op);
+template <typename CB ,             typename Dst,typename Op> Op static_transform(      CB&,Dst&,Op);
+template <typename CB ,             typename Dst,typename Op> Op static_transform(const CB&,Dst&,Op);
+template <typename CB1,typename CB2,typename Dst,typename Op> Op static_transform(      CB1&,      CB2&,Dst&,Op);
+template <typename CB1,typename CB2,typename Dst,typename Op> Op static_transform(const CB1&,      CB2&,Dst&,Op);
+template <typename CB1,typename CB2,typename Dst,typename Op> Op static_transform(      CB1&,const CB2&,Dst&,Op);
+template <typename CB1,typename CB2,typename Dst,typename Op> Op static_transform(const CB1&,const CB2&,Dst&,Op);
 
 // Equivalents to std::for_each
-template <typename CB1,                          typename Op> Op static_for_each(      CB1&,Op);
-template <typename CB1,                          typename Op> Op static_for_each(const CB1&,Op);
-template <typename CB1,typename CB2,             typename Op> Op static_for_each(      CB1&,      CB2&,Op);
-template <typename CB1,typename CB2,             typename Op> Op static_for_each(      CB1&,const CB2&,Op);
-template <typename CB1,typename CB2,             typename Op> Op static_for_each(const CB1&,      CB2&,Op);
-template <typename CB1,typename CB2,             typename Op> Op static_for_each(const CB1&,const CB2&,Op);
-template <typename CB1,typename CB2,typename CB3,typename Op> Op static_for_each(      CB1&,      CB2&,      CB3&,Op);
-template <typename CB1,typename CB2,typename CB3,typename Op> Op static_for_each(      CB1&,      CB2&,const CB3&,Op);
-template <typename CB1,typename CB2,typename CB3,typename Op> Op static_for_each(      CB1&,const CB2&,      CB3&,Op);
-template <typename CB1,typename CB2,typename CB3,typename Op> Op static_for_each(      CB1&,const CB2&,const CB3&,Op);
-template <typename CB1,typename CB2,typename CB3,typename Op> Op static_for_each(const CB1&,      CB2&,      CB3&,Op);
-template <typename CB1,typename CB2,typename CB3,typename Op> Op static_for_each(const CB1&,      CB2&,const CB3&,Op);
-template <typename CB1,typename CB2,typename CB3,typename Op> Op static_for_each(const CB1&,const CB2&,      CB3&,Op);
-template <typename CB1,typename CB2,typename CB3,typename Op> Op static_for_each(const CB1&,const CB2&,const CB3&,Op);
+template <typename CB1,                          typename Op> Op static_for_each(      CB1&,Op);
+template <typename CB1,                          typename Op> Op static_for_each(const CB1&,Op);
+template <typename CB1,typename CB2,             typename Op> Op static_for_each(      CB1&,      CB2&,Op);
+template <typename CB1,typename CB2,             typename Op> Op static_for_each(      CB1&,const CB2&,Op);
+template <typename CB1,typename CB2,             typename Op> Op static_for_each(const CB1&,      CB2&,Op);
+template <typename CB1,typename CB2,             typename Op> Op static_for_each(const CB1&,const CB2&,Op);
+template <typename CB1,typename CB2,typename CB3,typename Op> Op static_for_each(      CB1&,      CB2&,      CB3&,Op);
+template <typename CB1,typename CB2,typename CB3,typename Op> Op static_for_each(      CB1&,      CB2&,const CB3&,Op);
+template <typename CB1,typename CB2,typename CB3,typename Op> Op static_for_each(      CB1&,const CB2&,      CB3&,Op);
+template <typename CB1,typename CB2,typename CB3,typename Op> Op static_for_each(      CB1&,const CB2&,const CB3&,Op);
+template <typename CB1,typename CB2,typename CB3,typename Op> Op static_for_each(const CB1&,      CB2&,      CB3&,Op);
+template <typename CB1,typename CB2,typename CB3,typename Op> Op static_for_each(const CB1&,      CB2&,const CB3&,Op);
+template <typename CB1,typename CB2,typename CB3,typename Op> Op static_for_each(const CB1&,const CB2&,      CB3&,Op);
+template <typename CB1,typename CB2,typename CB3,typename Op> Op static_for_each(const CB1&,const CB2&,const CB3&,Op);
 
 // The following algorithms are only defined for homogeneous color bases:
 // Equivalent to std::fill
-template <typename HCB, typename Element> void static_fill(HCB& p, const Element& v);
+template <typename HCB, typename Element> void static_fill(HCB& p, const Element& v);
 
 // Equivalents to std::min_element and std::max_element
-template <typename HCB> typename element_const_reference_type<HCB>::type static_min(const HCB&);
-template <typename HCB> typename element_reference_type<HCB>::type       static_min(      HCB&);
-template <typename HCB> typename element_const_reference_type<HCB>::type static_max(const HCB&);
-template <typename HCB> typename element_reference_type<HCB>::type       static_max(      HCB&);
+template <typename HCB> typename element_const_reference_type<HCB>::type static_min(const HCB&);
+template <typename HCB> typename element_reference_type<HCB>::type       static_min(      HCB&);
+template <typename HCB> typename element_const_reference_type<HCB>::type static_max(const HCB&);
+template <typename HCB> typename element_reference_type<HCB>::type       static_max(      HCB&);
 

 

 
These algorithms are designed after the corresponding STL algorithms, except
@@ -268,23 +268,23 @@ based on their physical order in memory.

 
For example, here is the implementation of static_equal:

 
namespace detail
 {
-  template <int K> struct element_recursion
+  template <int K> struct element_recursion
   {
-    template <typename P1,typename P2>
+    template <typename P1,typename P2>
     static bool static_equal(const P1& p1, const P2& p2)
     {
-      return element_recursion<K-1>::static_equal(p1,p2) &&
-             semantic_at_c<K-1>(p1)==semantic_at_c<N-1>(p2);
+      return element_recursion<K-1>::static_equal(p1,p2) &&
+             semantic_at_c<K-1>(p1)==semantic_at_c<N-1>(p2);
     }
   };
-  template <> struct element_recursion<0>
+  template <> struct element_recursion<0>
   {
-    template <typename P1,typename P2>
+    template <typename P1,typename P2>
     static bool static_equal(const P1&, const P2&) { return true; }
   };
 }
 
-template <typename P1,typename P2>
+template <typename P1,typename P2>
 bool static_equal(const P1& p1, const P2& p2)
 {
   gil_function_requires<ColorSpacesCompatibleConcept<P1::layout_t::color_space_t,P2::layout_t::color_space_t> >();
@@ -310,8 +310,8 @@ color base require that they all have the same color space.

     

     

     
   
 
\ No newline at end of file
diff --git a/develop/doc/html/design/color_space.html b/develop/doc/html/design/color_space.html
index b9189f79b..7b1e26701 100644
--- a/develop/doc/html/design/color_space.html
+++ b/develop/doc/html/design/color_space.html
@@ -134,10 +134,10 @@ A color space and its associated mapping are often used together.

 
Thus they are grouped in GIL’s layout:

 
template
 <
-    typename ColorSpace,
-    typename ChannelMapping = mpl::range_c<int, 0, mpl::size<ColorSpace>::value>
+    typename ColorSpace,
+    typename ChannelMapping = mpl::range_c<int, 0, mpl::size<ColorSpace>::value>
 >
-struct layout
+struct layout
 {
   using color_space_t = ColorSpace;
   using channel_mapping_t = ChannelMapping;
@@ -165,8 +165,8 @@ A color space and its associated mapping are often used together.

     

     

     
   
 
\ No newline at end of file
diff --git a/develop/doc/html/design/concepts.html b/develop/doc/html/design/concepts.html
index 562e975a2..ee060fdfa 100644
--- a/develop/doc/html/design/concepts.html
+++ b/develop/doc/html/design/concepts.html
@@ -83,40 +83,40 @@ in the C++ standard proposal paper
 
Here are some common concepts that will be used in GIL.
 Most of them are defined at the
 ConceptC++ Concept Web:

-
auto concept DefaultConstructible<typename T>
+
auto concept DefaultConstructible<typename T>
 {
     T::T();
 };
 
-auto concept CopyConstructible<typename T>
+auto concept CopyConstructible<typename T>
 {
     T::T(T);
     T::~T();
 };
 
-auto concept Assignable<typename T, typename U = T>
+auto concept Assignable<typename T, typename U = T>
 {
-    typename result_type;
+    typename result_type;
     result_type operator=(T&, U);
 };
 
-auto concept EqualityComparable<typename T, typename U = T>
+auto concept EqualityComparable<typename T, typename U = T>
 {
     bool operator==(T x, U y);
     bool operator!=(T x, U y) { return !(x==y); }
 };
 
-concept SameType<typename T, typename U> { /* unspecified */ };
-template<typename T> concept_map SameType<T, T> { /* unspecified */ };
+concept SameType<typename T, typename U> { /* unspecified */ };
+template<typename T> concept_map SameType<T, T> { /* unspecified */ };
 
-auto concept Swappable<typename T>
+auto concept Swappable<typename T>
 {
-    void swap(T& t, T& u);
+    void swap(T& t, T& u);
 };
 

 

 
Here are some additional basic concepts that GIL needs:

-
auto concept Regular<typename T> :
+
auto concept Regular<typename T> :
     DefaultConstructible<T>,
     CopyConstructible<T>,
     EqualityComparable<T>,
@@ -124,9 +124,9 @@ Most of them are defined at the
     Swappable<T>
 {};
 
-auto concept Metafunction<typename T>
+auto concept Metafunction<typename T>
 {
-    typename type;
+    typename type;
 };
 

 

@@ -143,8 +143,8 @@ Most of them are defined at the
     

     

     
   
 
\ No newline at end of file
diff --git a/develop/doc/html/design/conclusions.html b/develop/doc/html/design/conclusions.html
index 4f9865dcb..e61451d7f 100644
--- a/develop/doc/html/design/conclusions.html
+++ b/develop/doc/html/design/conclusions.html
@@ -121,8 +121,8 @@ raw pixel data from another image library.

     

     

     
   
 
\ No newline at end of file
diff --git a/develop/doc/html/design/dynamic_image.html b/develop/doc/html/design/dynamic_image.html
index f51526288..d868bd159 100644
--- a/develop/doc/html/design/dynamic_image.html
+++ b/develop/doc/html/design/dynamic_image.html
@@ -95,7 +95,7 @@ What type is the image loading code supposed to return?

 ASSERT_SAME(my_any_image_t::const_view_t, my_any_image_t::view_t::const_t);
 
 typedef any_image_view<rgb8_step_view_t, cmyk16_planar_step_view_t> SAV;
-ASSERT_SAME(typename dynamic_x_step_type<my_any_image_t::view_t>::type, SAV);
+ASSERT_SAME(typename dynamic_x_step_type<my_any_image_t::view_t>::type, SAV);
 
 // Assign it a concrete image at run time:
 my_any_image_t myImg = my_any_image_t(rgb8_image_t(100,100));
@@ -121,10 +121,10 @@ a never valueless variant type, compatible with using size_type = std::size_t;
 
   any_image_view();
-  template <typename T> explicit any_image_view(const T& obj);
+  template <typename T> explicit any_image_view(const T& obj);
   any_image_view(const any_image_view& v);
 
-  template <typename T> any_image_view& operator=(const T& obj);
+  template <typename T> any_image_view& operator=(const T& obj);
   any_image_view&                       operator=(const any_image_view& v);
 
   // parameters of the currently instantiated view
@@ -146,11 +146,11 @@ a never valueless variant type, compatible with typedef point<std::ptrdiff_t> point_t;
 
   any_image();
-  template <typename T> explicit any_image(const T& obj);
-  template <typename T> explicit any_image(T& obj, bool do_swap);
+  template <typename T> explicit any_image(const T& obj);
+  template <typename T> explicit any_image(T& obj, bool do_swap);
   any_image(const any_image& v);
 
-  template <typename T> any_image& operator=(const T& obj);
+  template <typename T> any_image& operator=(const T& obj);
   any_image&                       operator=(const any_image& v);
 
   void recreate(const point_t& dims, unsigned alignment=1);
@@ -214,7 +214,7 @@ code, for example, uses the GIL I/O extension to turn an image on disk
 upside down:

 
#include <boost\gil\extension\io\jpeg_dynamic_io.hpp>
 
-template <typename Image>    // Could be rgb8_image_t or any_image<...>
+template <typename Image>    // Could be rgb8_image_t or any_image<...>
 void save_180rot(const std::string& file_name)
 {
   Image img;
@@ -228,28 +228,28 @@ because all functions it uses have overloads taking runtime
 constructs. For example, here is how rotated180_view is
 implemented:

 
// implementation using templated view
-template <typename View>
-typename dynamic_xy_step_type<View>::type rotated180_view(const View& src) { ... }
+template <typename View>
+typename dynamic_xy_step_type<View>::type rotated180_view(const View& src) { ... }
 
 namespace detail
 {
   // the function, wrapped inside a function object
-  template <typename Result> struct rotated180_view_fn
+  template <typename Result> struct rotated180_view_fn
   {
       typedef Result result_type;
-      template <typename View> result_type operator()(const View& src) const
+      template <typename View> result_type operator()(const View& src) const
 {
-          return result_type(rotated180_view(src));
+          return result_type(rotated180_view(src));
       }
   };
 }
 
 // overloading of the function using variant. Takes and returns run-time bound view.
 // The returned view has a dynamic step
-template <typename ViewTypes> inline // Models MPL Random Access Container of models of ImageViewConcept
-typename dynamic_xy_step_type<any_image_view<ViewTypes> >::type rotated180_view(const any_image_view<ViewTypes>& src)
+template <typename ViewTypes> inline // Models MPL Random Access Container of models of ImageViewConcept
+typename dynamic_xy_step_type<any_image_view<ViewTypes> >::type rotated180_view(const any_image_view<ViewTypes>& src)
 {
-  return apply_operation(src,detail::rotated180_view_fn<typename dynamic_xy_step_type<any_image_view<ViewTypes> >::type>());
+  return apply_operation(src,detail::rotated180_view_fn<typename dynamic_xy_step_type<any_image_view<ViewTypes> >::type>());
 }
 

 

@@ -274,8 +274,8 @@ uniformly as a collection and store them in the same container.

     

     

     
   
 
\ No newline at end of file
diff --git a/develop/doc/html/design/examples.html b/develop/doc/html/design/examples.html
index 0435510d2..3150fcc39 100644
--- a/develop/doc/html/design/examples.html
+++ b/develop/doc/html/design/examples.html
@@ -105,20 +105,20 @@ pixel references:

 

 

 
Here is how to use pixels in generic code:

-
template <typename GrayPixel, typename RGBPixel>
+
template <typename GrayPixel, typename RGBPixel>
 void gray_to_rgb(const GrayPixel& src, RGBPixel& dst)
 {
   gil_function_requires<PixelConcept<GrayPixel> >();
   gil_function_requires<MutableHomogeneousPixelConcept<RGBPixel> >();
 
-  typedef typename color_space_type<GrayPixel>::type gray_cs_t;
+  typedef typename color_space_type<GrayPixel>::type gray_cs_t;
   static_assert(boost::is_same<gray_cs_t,gray_t>::value, "");
 
-  typedef typename color_space_type<RGBPixel>::type  rgb_cs_t;
+  typedef typename color_space_type<RGBPixel>::type  rgb_cs_t;
   static_assert(boost::is_same<rgb_cs_t,rgb_t>::value, "");
 
-  typedef typename channel_type<GrayPixel>::type gray_channel_t;
-  typedef typename channel_type<RGBPixel>::type  rgb_channel_t;
+  typedef typename channel_type<GrayPixel>::type gray_channel_t;
+  typedef typename channel_type<RGBPixel>::type  rgb_channel_t;
 
   gray_channel_t gray = get_color(src,gray_color_t());
   static_fill(dst, channel_convert<rgb_channel_t>(gray));
@@ -147,16 +147,16 @@ pixels. Size of canvas of an image can never be smaller than the image itself.Suppose we want to convolve an image with multiple kernels, the largest of
 which is 2K+1 x 2K+1 pixels. It may be worth creating a margin of K pixels
 around the image borders. Here is how to do it:

-
template <typename SrcView,   // Models ImageViewConcept (the source view)
-        typename DstImage>  // Models ImageConcept     (the returned image)
+
template <typename SrcView,   // Models ImageViewConcept (the source view)
+        typename DstImage>  // Models ImageConcept     (the returned image)
 void create_with_margin(const SrcView& src, int k, DstImage& result)
 {
   gil_function_requires<ImageViewConcept<SrcView> >();
   gil_function_requires<ImageConcept<DstImage> >();
-  gil_function_requires<ViewsCompatibleConcept<SrcView, typename DstImage::view_t> >();
+  gil_function_requires<ViewsCompatibleConcept<SrcView, typename DstImage::view_t> >();
 
   result=DstImage(src.width()+2*k, src.height()+2*k);
-  typename DstImage::view_t centerImg=subimage_view(view(result), k,k,src.width(),src.height());
+  typename DstImage::view_t centerImg=subimage_view(view(result), k,k,src.width(),src.height());
   std::copy(src.begin(), src.end(), centerImg.begin());
 }
 

@@ -166,7 +166,7 @@ shallow image of its center area of top left corner at (k,k) and of identical
 size as src, and finally we copied src into that center image. If the
 margin needs initialization, we could have done it with fill_pixels. Here
 is how to simplify this code using the copy_pixels algorithm:

-
template <typename SrcView, typename DstImage>
+
template <typename SrcView, typename DstImage>
 void create_with_margin(const SrcView& src, int k, DstImage& result)
 {
   result.recreate(src.width()+2*k, src.height()+2*k);
@@ -191,17 +191,17 @@ taking into account both static and run-time parameters.

 
The histogram can be computed by counting the number of pixel values that fall
 in each bin. The following method takes a grayscale (one-dimensional) image
 view, since only grayscale pixels are convertible to integers:

-
template <typename GrayView, typename R>
+
template <typename GrayView, typename R>
 void grayimage_histogram(const GrayView& img, R& hist)
 {
-  for (typename GrayView::iterator it=img.begin(); it!=img.end(); ++it)
+  for (typename GrayView::iterator it=img.begin(); it!=img.end(); ++it)
       ++hist[*it];
 }
 

 

 
Using boost::lambda and GIL’s for_each_pixel algorithm, we can write
 this more compactly:

-
template <typename GrayView, typename R>
+
template <typename GrayView, typename R>
 void grayimage_histogram(const GrayView& v, R& hist)
 {
   for_each_pixel(v, ++var(hist)[_1]);
@@ -211,7 +211,7 @@ this more compactly:

 
Where for_each_pixel invokes std::for_each and var and _1 are
 boost::lambda constructs. To compute the luminosity histogram, we call the
 above method using the grayscale view of an image:

-
template <typename View, typename R>
+
template <typename View, typename R>
 void luminosity_histogram(const View& v, R& hist)
 {
   grayimage_histogram(color_converted_view<gray8_pixel_t>(v),hist);
@@ -264,8 +264,8 @@ channel depth. They could be either planar or interleaved.

     

     

     
   
 
\ No newline at end of file
diff --git a/develop/doc/html/design/extending.html b/develop/doc/html/design/extending.html
index 36e9ec2ed..515cd5f51 100644
--- a/develop/doc/html/design/extending.html
+++ b/develop/doc/html/design/extending.html
@@ -121,16 +121,16 @@ cases. Here is, for example, how to overload color conversion so that
 color conversion to gray inverts the result but everything else
 remains the same:

 
// make the default use GIL's default
-template <typename SrcColorSpace, typename DstColorSpace>
-struct my_color_converter_impl
-: public default_color_converter_impl<SrcColorSpace,DstColorSpace> {};
+template <typename SrcColorSpace, typename DstColorSpace>
+struct my_color_converter_impl
+: public default_color_converter_impl<SrcColorSpace,DstColorSpace> {};
 
 // provide specializations only for cases you care about
 // (in this case, if the destination is grayscale, invert it)
-template <typename SrcColorSpace>
-struct my_color_converter_impl<SrcColorSpace,gray_t>
+template <typename SrcColorSpace>
+struct my_color_converter_impl<SrcColorSpace,gray_t>
 {
-  template <typename SrcP, typename DstP>  // Model PixelConcept
+  template <typename SrcP, typename DstP>  // Model PixelConcept
   void operator()(const SrcP& src, DstP& dst) const
   {
       default_color_converter_impl<SrcColorSpace,gray_t>()(src,dst);
@@ -139,13 +139,13 @@ remains the same:

 };
 
 // create a color converter object that dispatches to your own implementation
-struct my_color_converter
+struct my_color_converter
 {
-  template <typename SrcP, typename DstP>  // Model PixelConcept
+  template <typename SrcP, typename DstP>  // Model PixelConcept
   void operator()(const SrcP& src,DstP& dst) const
   {
-      typedef typename color_space_type<SrcP>::type SrcColorSpace;
-      typedef typename color_space_type<DstP>::type DstColorSpace;
+      typedef typename color_space_type<SrcP>::type SrcColorSpace;
+      typedef typename color_space_type<DstP>::type DstColorSpace;
       my_color_converter_impl<SrcColorSpace,DstColorSpace>()(src,dst);
   }
 };
@@ -169,8 +169,8 @@ pixel access). First we need to define a model of
 PixelDereferenceAdaptorConcept; a function object that will be
 called when we dereference a pixel iterator. It will call
 color_convert to convert to the destination pixel type:

-
template <typename SrcConstRefP,  // const reference to the source pixel
-        typename DstP>          // Destination pixel value (models PixelValueConcept)
+
template <typename SrcConstRefP,  // const reference to the source pixel
+        typename DstP>          // Destination pixel value (models PixelValueConcept)
 class color_convert_deref_fn
 {
 public:
@@ -193,23 +193,23 @@ called when we dereference a pixel iterator. It will call
 
We then use the add_deref member struct of image views to construct the
 type of a view that invokes a given function object (deref_t) upon
 dereferencing. In our case, it performs color conversion:

-
template <typename SrcView, typename DstP>
-struct color_converted_view_type
+
template <typename SrcView, typename DstP>
+struct color_converted_view_type
 {
 private:
-  typedef typename SrcView::const_t::reference src_pix_ref;  // const reference to pixel in SrcView
+  typedef typename SrcView::const_t::reference src_pix_ref;  // const reference to pixel in SrcView
   typedef color_convert_deref_fn<src_pix_ref, DstP> deref_t; // the dereference adaptor that performs color conversion
-  typedef typename SrcView::template add_deref<deref_t> add_ref_t;
+  typedef typename SrcView::template add_deref<deref_t> add_ref_t;
 public:
-  typedef typename add_ref_t::type type; // the color converted view type
-  static type make(const SrcView& sv) { return add_ref_t::make(sv, deref_t()); }
+  typedef typename add_ref_t::type type; // the color converted view type
+  static type make(const SrcView& sv) { return add_ref_t::make(sv, deref_t()); }
 };
 

 

 
Finally our color_converted_view code simply creates color-converted view
 from the source view:

-
template <typename DstP, typename View> inline
-typename color_converted_view_type<View,DstP>::type color_convert_view(const View& src)
+
template <typename DstP, typename View> inline
+typename color_converted_view_type<View,DstP>::type color_convert_view(const View& src)
 {
   return color_converted_view_type<View,DstP>::make(src);
 }
@@ -234,8 +234,8 @@ defines the Mandelbrot set.

     

     

     
   
 
\ No newline at end of file
diff --git a/develop/doc/html/design/image.html b/develop/doc/html/design/image.html
index ef358e3b2..b3e8a706b 100644
--- a/develop/doc/html/design/image.html
+++ b/develop/doc/html/design/image.html
@@ -84,13 +84,13 @@ ranges, not containers. Similarly most GIL algorithms operate on image views
 (which images provide).

 
In the most general form images are N-dimensional and satisfy the following
 concept:

-
concept RandomAccessNDImageConcept<typename Img> : Regular<Img>
+
concept RandomAccessNDImageConcept<typename Img> : Regular<Img>
 {
-  typename view_t; where MutableRandomAccessNDImageViewConcept<view_t>;
-  typename const_view_t = view_t::const_t;
-  typename point_t      = view_t::point_t;
-  typename value_type   = view_t::value_type;
-  typename allocator_type;
+  typename view_t; where MutableRandomAccessNDImageViewConcept<view_t>;
+  typename const_view_t = view_t::const_t;
+  typename point_t      = view_t::point_t;
+  typename value_type   = view_t::value_type;
+  typename allocator_type;
 
   Img::Img(point_t dims, std::size_t alignment=0);
   Img::Img(point_t dims, value_type fill_value, std::size_t alignment);
@@ -105,10 +105,10 @@ concept:

 

 

 
Two-dimensional images have additional requirements:

-
concept RandomAccess2DImageConcept<RandomAccessNDImageConcept Img>
+
concept RandomAccess2DImageConcept<RandomAccessNDImageConcept Img>
 {
-  typename x_coord_t = const_view_t::x_coord_t;
-  typename y_coord_t = const_view_t::y_coord_t;
+  typename x_coord_t = const_view_t::x_coord_t;
+  typename y_coord_t = const_view_t::y_coord_t;
 
   Img::Img(x_coord_t width, y_coord_t height, std::size_t alignment=0);
   Img::Img(x_coord_t width, y_coord_t height, value_type fill_value, std::size_t alignment);
@@ -122,10 +122,10 @@ concept:

 

 

 
GIL images have views that model ImageViewConcept and operate on pixels.

-
concept ImageConcept<RandomAccess2DImageConcept Img>
+
concept ImageConcept<RandomAccess2DImageConcept Img>
 {
   where MutableImageViewConcept<view_t>;
-  typename coord_t  = view_t::coord_t;
+  typename coord_t  = view_t::coord_t;
 };
 

 

@@ -146,9 +146,9 @@ because immutable images are not very useful.

 (the pixel) and models ImageConcept:

 
 template
  <
-     typename Pixel, // Models PixelValueConcept
+     typename Pixel, // Models PixelValueConcept
      bool IsPlanar,  // planar or interleaved image
-     typename A=std::allocator<unsigned char>
+     typename A=std::allocator<unsigned char>
  >
 class image;
 

@@ -175,8 +175,8 @@ there are no padding bits at the end of rows of packed images.

     

     

     
   
 
\ No newline at end of file
diff --git a/develop/doc/html/design/image_view.html b/develop/doc/html/design/image_view.html
index 2b8d0772c..263aeb688 100644
--- a/develop/doc/html/design/image_view.html
+++ b/develop/doc/html/design/image_view.html
@@ -90,30 +90,30 @@ For example, a constant image view cannot be resized, but may allow modifying
 the pixels. For pixel-immutable operations, use constant-value image view
 (also called non-mutable image view). Most general N-dimensional views satisfy
 the following concept:

-
concept RandomAccessNDImageViewConcept<Regular View>
+
concept RandomAccessNDImageViewConcept<Regular View>
 {
-  typename value_type;      // for pixel-based views, the pixel type
-  typename reference;       // result of dereferencing
-  typename difference_type; // result of operator-(iterator,iterator) (1-dimensional!)
-  typename const_t;  where RandomAccessNDImageViewConcept<View>; // same as View, but over immutable values
-  typename point_t;  where PointNDConcept<point_t>; // N-dimensional point
-  typename locator;  where RandomAccessNDLocatorConcept<locator>; // N-dimensional locator.
-  typename iterator; where RandomAccessTraversalConcept<iterator>; // 1-dimensional iterator over all values
-  typename reverse_iterator; where RandomAccessTraversalConcept<reverse_iterator>;
-  typename size_type;       // the return value of size()
+  typename value_type;      // for pixel-based views, the pixel type
+  typename reference;       // result of dereferencing
+  typename difference_type; // result of operator-(iterator,iterator) (1-dimensional!)
+  typename const_t;  where RandomAccessNDImageViewConcept<View>; // same as View, but over immutable values
+  typename point_t;  where PointNDConcept<point_t>; // N-dimensional point
+  typename locator;  where RandomAccessNDLocatorConcept<locator>; // N-dimensional locator.
+  typename iterator; where RandomAccessTraversalConcept<iterator>; // 1-dimensional iterator over all values
+  typename reverse_iterator; where RandomAccessTraversalConcept<reverse_iterator>;
+  typename size_type;       // the return value of size()
 
   // Equivalent to RandomAccessNDLocatorConcept::axis
-  template <size_t D> struct axis {
-      typename coord_t = point_t::axis<D>::coord_t;
-      typename iterator; where RandomAccessTraversalConcept<iterator>;   // iterator along D-th axis.
+  template <size_t D> struct axis {
+      typename coord_t = point_t::axis<D>::coord_t;
+      typename iterator; where RandomAccessTraversalConcept<iterator>;   // iterator along D-th axis.
       where SameType<coord_t, iterator::difference_type>;
       where SameType<iterator::value_type,value_type>;
   };
 
   // Defines the type of a view similar to this type, except it invokes Deref upon dereferencing
-  template <PixelDereferenceAdaptorConcept Deref> struct add_deref {
-      typename type;        where RandomAccessNDImageViewConcept<type>;
-      static type make(const View& v, const Deref& deref);
+  template <PixelDereferenceAdaptorConcept Deref> struct add_deref {
+      typename type;        where RandomAccessNDImageViewConcept<type>;
+      static type make(const View& v, const Deref& deref);
   };
 
   static const size_t num_dimensions = point_t::num_dimensions;
@@ -137,22 +137,22 @@ the following concept:

   reference operator()(View,const point_t&) const;
 };
 
-concept MutableRandomAccessNDImageViewConcept<RandomAccessNDImageViewConcept View>
+concept MutableRandomAccessNDImageViewConcept<RandomAccessNDImageViewConcept View>
 {
   where Mutable<reference>;
 };
 

 

 
Two-dimensional image views have the following extra requirements:

-
concept RandomAccess2DImageViewConcept<RandomAccessNDImageViewConcept View>
+
concept RandomAccess2DImageViewConcept<RandomAccessNDImageViewConcept View>
 {
   where num_dimensions==2;
 
-  typename x_iterator = axis<0>::iterator;
-  typename y_iterator = axis<1>::iterator;
-  typename x_coord_t  = axis<0>::coord_t;
-  typename y_coord_t  = axis<1>::coord_t;
-  typename xy_locator = locator;
+  typename x_iterator = axis<0>::iterator;
+  typename y_iterator = axis<1>::iterator;
+  typename x_coord_t  = axis<0>::coord_t;
+  typename y_coord_t  = axis<1>::coord_t;
+  typename xy_locator = locator;
 
   x_coord_t View::width()  const;
   y_coord_t View::height() const;
@@ -179,33 +179,33 @@ the following concept:

   y_iterator View::y_at(x_coord_t,y_coord_t) const;
 };
 
-concept MutableRandomAccess2DImageViewConcept<RandomAccess2DImageViewConcept View>
+concept MutableRandomAccess2DImageViewConcept<RandomAccess2DImageViewConcept View>
   : MutableRandomAccessNDImageViewConcept<View> {};
 

 

 
Image views that GIL typically uses operate on value types that model
 PixelValueConcept and have some additional requirements:

-
concept ImageViewConcept<RandomAccess2DImageViewConcept View>
+
concept ImageViewConcept<RandomAccess2DImageViewConcept View>
 {
   where PixelValueConcept<value_type>;
   where PixelIteratorConcept<x_iterator>;
   where PixelIteratorConcept<y_iterator>;
   where x_coord_t == y_coord_t;
 
-  typename coord_t = x_coord_t;
+  typename coord_t = x_coord_t;
 
   std::size_t View::num_channels() const;
 };
 
 
-concept MutableImageViewConcept<ImageViewConcept View>
+concept MutableImageViewConcept<ImageViewConcept View>
   : MutableRandomAccess2DImageViewConcept<View>
 {};
 

 

 
Two image views are compatible if they have compatible pixels and the same
 number of dimensions:

-
concept ViewsCompatibleConcept<ImageViewConcept V1, ImageViewConcept V2>
+
concept ViewsCompatibleConcept<ImageViewConcept V1, ImageViewConcept V2>
 {
   where PixelsCompatibleConcept<V1::value_type, V2::value_type>;
   where V1::num_dimensions == V2::num_dimensions;
@@ -235,7 +235,7 @@ templated over a model of MutablePixelLocatorConcept, it models
 MutableImageViewConcept). Synopsis:

 
// Locator models PixelLocatorConcept, could be MutablePixelLocatorConcept
-template <typename Locator>
+template <typename Locator>
 class image_view
 {
 public:
@@ -263,14 +263,14 @@ space, bit depth, channel ordering or planar vs. interleaved structure.
 Interleaved views are constructed using interleaved_view, supplying the
 image dimensions, number of bytes per row, and a pointer to the first pixel:

 
// Iterator models pixel iterator (e.g. rgb8_ptr_t or rgb8c_ptr_t)
-template <typename Iterator>
+template <typename Iterator>
 image_view<...> interleaved_view(ptrdiff_t width, ptrdiff_t height, Iterator pixels, ptrdiff_t rowsize)
 

 

 
Planar views are defined for every color space and take each plane separately.
 Here is the RGB one:

 
// Iterator models channel iterator (e.g. bits8* or bits8 const*)
-template <typename Iterator>
+template <typename Iterator>
 image_view<...> planar_rgb_view(
     ptrdiff_t width, ptrdiff_t height,
     IC r, IC g, IC b, ptrdiff_t rowsize);
@@ -286,24 +286,24 @@ policy of how image data is interpreted. The result could be a view whose type
 is derived from the type of the source. GIL uses the following metafunctions
 to get the derived types:

 
// Some result view types
-template <typename View>
-struct dynamic_xy_step_type : public dynamic_y_step_type<typename dynamic_x_step_type<View>::type> {};
+template <typename View>
+struct dynamic_xy_step_type : public dynamic_y_step_type<typename dynamic_x_step_type<View>::type> {};
 
-template <typename View>
-struct dynamic_xy_step_transposed_type : public dynamic_xy_step_type<typename transposed_type<View>::type> {};
+template <typename View>
+struct dynamic_xy_step_transposed_type : public dynamic_xy_step_type<typename transposed_type<View>::type> {};
 
 // color and bit depth converted view to match pixel type P
-template <typename SrcView, // Models ImageViewConcept
-        typename DstP,    // Models PixelConcept
-        typename ColorConverter=gil::default_color_converter>
-struct color_converted_view_type
+template <typename SrcView, // Models ImageViewConcept
+        typename DstP,    // Models PixelConcept
+        typename ColorConverter=gil::default_color_converter>
+struct color_converted_view_type
 {
   typedef ... type;     // image view adaptor with value type DstP, over SrcView
 };
 
 // single-channel view of the N-th channel of a given view
-template <typename SrcView>
-struct nth_channel_view_type
+template <typename SrcView>
+struct nth_channel_view_type
 {
   typedef ... type;
 };
@@ -311,29 +311,29 @@ to get the derived types:

 

 
GIL Provides the following view transformations:

 
// flipped upside-down, left-to-right, transposed view
-template <typename View> typename dynamic_y_step_type<View>::type             flipped_up_down_view(const View& src);
-template <typename View> typename dynamic_x_step_type<View>::type             flipped_left_right_view(const View& src);
-template <typename View> typename dynamic_xy_step_transposed_type<View>::type transposed_view(const View& src);
+template <typename View> typename dynamic_y_step_type<View>::type             flipped_up_down_view(const View& src);
+template <typename View> typename dynamic_x_step_type<View>::type             flipped_left_right_view(const View& src);
+template <typename View> typename dynamic_xy_step_transposed_type<View>::type transposed_view(const View& src);
 
 // rotations
-template <typename View> typename dynamic_xy_step_type<View>::type            rotated180_view(const View& src);
-template <typename View> typename dynamic_xy_step_transposed_type<View>::type rotated90cw_view(const View& src);
-template <typename View> typename dynamic_xy_step_transposed_type<View>::type rotated90ccw_view(const View& src);
+template <typename View> typename dynamic_xy_step_type<View>::type            rotated180_view(const View& src);
+template <typename View> typename dynamic_xy_step_transposed_type<View>::type rotated90cw_view(const View& src);
+template <typename View> typename dynamic_xy_step_transposed_type<View>::type rotated90ccw_view(const View& src);
 
 // view of an axis-aligned rectangular area within an image
-template <typename View> View                                                 subimage_view(const View& src,
+template <typename View> View                                                 subimage_view(const View& src,
            const View::point_t& top_left, const View::point_t& dimensions);
 
 // subsampled view (skipping pixels in X and Y)
-template <typename View> typename dynamic_xy_step_type<View>::type            subsampled_view(const View& src,
+template <typename View> typename dynamic_xy_step_type<View>::type            subsampled_view(const View& src,
            const View::point_t& step);
 
-template <typename View, typename P>
+template <typename View, typename P>
 color_converted_view_type<View,P>::type                                       color_converted_view(const View& src);
-template <typename View, typename P, typename CCV> // with a custom color converter
+template <typename View, typename P, typename CCV> // with a custom color converter
 color_converted_view_type<View,P,CCV>::type                                   color_converted_view(const View& src);
 
-template <typename View>
+template <typename View>
 nth_channel_view_type<View>::view_t                                           nth_channel_view(const View& view, int n);
 

 

@@ -341,12 +341,12 @@ to get the derived types:

 Here is, for example, how the flip views are implemented. The flip upside-down
 view creates a view whose first pixel is the bottom left pixel of the original
 view and whose y-step is the negated step of the source.

-
template <typename View>
-typename dynamic_y_step_type<View>::type flipped_up_down_view(const View& src)
+
template <typename View>
+typename dynamic_y_step_type<View>::type flipped_up_down_view(const View& src)
 {
   gil_function_requires<ImageViewConcept<View> >();
-  typedef typename dynamic_y_step_type<View>::type RView;
-  return RView(src.dimensions(),typename RView::xy_locator(src.xy_at(0,src.height()-1),-1));
+  typedef typename dynamic_y_step_type<View>::type RView;
+  return RView(src.dimensions(),typename RView::xy_locator(src.xy_at(0,src.height()-1),-1));
 }
 

 

@@ -383,30 +383,30 @@ The algorithms in this section resemble STL algorithms, but they abstract away
 the nested loops and take views (as opposed to ranges) as input.

 
// Equivalents of std::copy and std::uninitialized_copy
 // where ImageViewConcept<V1>, MutableImageViewConcept<V2>, ViewsCompatibleConcept<V1,V2>
-template <typename V1, typename V2>
+template <typename V1, typename V2>
 void copy_pixels(const V1& src, const V2& dst);
-template <typename V1, typename V2>
+template <typename V1, typename V2>
 void uninitialized_copy_pixels(const V1& src, const V2& dst);
 
 // Equivalents of std::fill and std::uninitialized_fill
 // where MutableImageViewConcept<V>, PixelConcept<Value>, PixelsCompatibleConcept<Value,V::value_type>
-template <typename V, typename Value>
+template <typename V, typename Value>
 void fill_pixels(const V& dst, const Value& val);
-template <typename V, typename Value>
+template <typename V, typename Value>
 void uninitialized_fill_pixels(const V& dst, const Value& val);
 
 // Equivalent of std::for_each
 // where ImageViewConcept<V>, boost::UnaryFunctionConcept<F>
 // where PixelsCompatibleConcept<V::reference, F::argument_type>
-template <typename V, typename F>
+template <typename V, typename F>
 F for_each_pixel(const V& view, F fun);
-template <typename V, typename F>
+template <typename V, typename F>
 F for_each_pixel_position(const V& view, F fun);
 
 // Equivalent of std::generate
 // where MutableImageViewConcept<V>, boost::UnaryFunctionConcept<F>
 // where PixelsCompatibleConcept<V::reference, F::argument_type>
-template <typename V, typename F>
+template <typename V, typename F>
 void generate_pixels(const V& dst, F fun);
 
 // Equivalent of std::transform with one source
@@ -414,9 +414,9 @@ the nested loops and take views (as opposed to ranges) as input.

 // where boost::UnaryFunctionConcept<F>
 // where PixelsCompatibleConcept<V1::const_reference, F::argument_type>
 // where PixelsCompatibleConcept<F::result_type, V2::reference>
-template <typename V1, typename V2, typename F>
+template <typename V1, typename V2, typename F>
 F transform_pixels(const V1& src, const V2& dst, F fun);
-template <typename V1, typename V2, typename F>
+template <typename V1, typename V2, typename F>
 F transform_pixel_positions(const V1& src, const V2& dst, F fun);
 
 // Equivalent of std::transform with two sources
@@ -425,22 +425,22 @@ the nested loops and take views (as opposed to ranges) as input.

 // where PixelsCompatibleConcept<V1::const_reference, F::first_argument_type>
 // where PixelsCompatibleConcept<V2::const_reference, F::second_argument_type>
 // where PixelsCompatibleConcept<F::result_type, V3::reference>
-template <typename V1, typename V2, typename V3, typename F>
+template <typename V1, typename V2, typename V3, typename F>
 F transform_pixels(const V1& src1, const V2& src2, const V3& dst, F fun);
-template <typename V1, typename V2, typename V3, typename F>
+template <typename V1, typename V2, typename V3, typename F>
 F transform_pixel_positions(const V1& src1, const V2& src2, const V3& dst, F fun);
 
 // Copies a view into another, color converting the pixels if needed, with the default or user-defined color converter
 // where ImageViewConcept<V1>, MutableImageViewConcept<V2>
 // V1::value_type must be convertible to V2::value_type.
-template <typename V1, typename V2>
+template <typename V1, typename V2>
 void copy_and_convert_pixels(const V1& src, const V2& dst);
-template <typename V1, typename V2, typename ColorConverter>
+template <typename V1, typename V2, typename ColorConverter>
 void copy_and_convert_pixels(const V1& src, const V2& dst, ColorConverter ccv);
 
 // Equivalent of std::equal
 // where ImageViewConcept<V1>, ImageViewConcept<V2>, ViewsCompatibleConcept<V1,V2>
-template <typename V1, typename V2>
+template <typename V1, typename V2>
 bool equal_pixels(const V1& view1, const V2& view2);
 

 

@@ -487,8 +487,8 @@ development and is not optimized for speed

     

     

     
   
 
\ No newline at end of file
diff --git a/develop/doc/html/design/index.html b/develop/doc/html/design/index.html
index 68c8e6194..dc03c1fbc 100644
--- a/develop/doc/html/design/index.html
+++ b/develop/doc/html/design/index.html
@@ -102,8 +102,8 @@ structure and basic elements of the Generic Image Library (GIL).

     

     

     
   
 
\ No newline at end of file
diff --git a/develop/doc/html/design/metafunctions.html b/develop/doc/html/design/metafunctions.html
index ecb977a9d..0f91a785f 100644
--- a/develop/doc/html/design/metafunctions.html
+++ b/develop/doc/html/design/metafunctions.html
@@ -112,29 +112,29 @@ to interleaved). _s
 homogeneous memory-based GIL constructs given a channel type, a
 layout, and whether the construct is planar, has a step along the X
 direction, and is mutable:

-
template <typename ChannelValue, typename Layout, bool IsPlanar=false, bool IsMutable=true>
-struct pixel_reference_type { typedef ... type; };
+
template <typename ChannelValue, typename Layout, bool IsPlanar=false, bool IsMutable=true>
+struct pixel_reference_type { typedef ... type; };
 
-template <typename Channel, typename Layout>
-struct pixel_value_type { typedef ... type; };
+template <typename Channel, typename Layout>
+struct pixel_value_type { typedef ... type; };
 
-template <typename ChannelValue, typename Layout, bool IsPlanar=false, bool IsStep=false,  bool IsMutable=true>
-struct iterator_type { typedef ... type; };
+template <typename ChannelValue, typename Layout, bool IsPlanar=false, bool IsStep=false,  bool IsMutable=true>
+struct iterator_type { typedef ... type; };
 
-template <typename ChannelValue, typename Layout, bool IsPlanar=false, bool IsXStep=false, bool IsMutable=true>
-struct locator_type { typedef ... type; };
+template <typename ChannelValue, typename Layout, bool IsPlanar=false, bool IsXStep=false, bool IsMutable=true>
+struct locator_type { typedef ... type; };
 
-template <typename ChannelValue, typename Layout, bool IsPlanar=false, bool IsXStep=false, bool IsMutable=true>
-struct view_type { typedef ... type; };
+template <typename ChannelValue, typename Layout, bool IsPlanar=false, bool IsXStep=false, bool IsMutable=true>
+struct view_type { typedef ... type; };
 
-template <typename ChannelValue, typename Layout, bool IsPlanar=false, typename Alloc=std::allocator<unsigned char> >
-struct image_type { typedef ... type; };
+template <typename ChannelValue, typename Layout, bool IsPlanar=false, typename Alloc=std::allocator<unsigned char> >
+struct image_type { typedef ... type; };
 
-template <typename BitField, typename ChannelBitSizeVector, typename Layout, typename Alloc=std::allocator<unsigned char> >
-struct packed_image_type { typedef ... type; };
+template <typename BitField, typename ChannelBitSizeVector, typename Layout, typename Alloc=std::allocator<unsigned char> >
+struct packed_image_type { typedef ... type; };
 
-template <typename ChannelBitSizeVector, typename Layout, typename Alloc=std::allocator<unsigned char> >
-struct bit_aligned_image_type { typedef ... type; };
+template <typename ChannelBitSizeVector, typename Layout, typename Alloc=std::allocator<unsigned char> >
+struct bit_aligned_image_type { typedef ... type; };
 

 

 

@@ -142,45 +142,45 @@ direction, and is mutable:

 
Packed and bit-aligned images

 
There are also helper metafunctions to construct packed and
 bit-aligned images with up to five channels:

-
template <typename BitField, unsigned Size1,
-        typename Layout, typename Alloc=std::allocator<unsigned char> >
-struct packed_image1_type { typedef ... type; };
+
template <typename BitField, unsigned Size1,
+        typename Layout, typename Alloc=std::allocator<unsigned char> >
+struct packed_image1_type { typedef ... type; };
 
-template <typename BitField, unsigned Size1, unsigned Size2,
-        typename Layout, typename Alloc=std::allocator<unsigned char> >
-struct packed_image2_type { typedef ... type; };
+template <typename BitField, unsigned Size1, unsigned Size2,
+        typename Layout, typename Alloc=std::allocator<unsigned char> >
+struct packed_image2_type { typedef ... type; };
 
-template <typename BitField, unsigned Size1, unsigned Size2, unsigned Size3,
-        typename Layout, typename Alloc=std::allocator<unsigned char> >
-struct packed_image3_type { typedef ... type; };
+template <typename BitField, unsigned Size1, unsigned Size2, unsigned Size3,
+        typename Layout, typename Alloc=std::allocator<unsigned char> >
+struct packed_image3_type { typedef ... type; };
 
-template <typename BitField, unsigned Size1, unsigned Size2, unsigned Size3, unsigned Size4,
-        typename Layout, typename Alloc=std::allocator<unsigned char> >
-struct packed_image4_type { typedef ... type; };
+template <typename BitField, unsigned Size1, unsigned Size2, unsigned Size3, unsigned Size4,
+        typename Layout, typename Alloc=std::allocator<unsigned char> >
+struct packed_image4_type { typedef ... type; };
 
-template <typename BitField, unsigned Size1, unsigned Size2, unsigned Size3, unsigned Size4, unsigned Size5,
-        typename Layout, typename Alloc=std::allocator<unsigned char> >
-struct packed_image5_type { typedef ... type; };
+template <typename BitField, unsigned Size1, unsigned Size2, unsigned Size3, unsigned Size4, unsigned Size5,
+        typename Layout, typename Alloc=std::allocator<unsigned char> >
+struct packed_image5_type { typedef ... type; };
 
 template <unsigned Size1,
-        typename Layout, typename Alloc=std::allocator<unsigned char> >
-struct bit_aligned_image1_type { typedef ... type; };
+        typename Layout, typename Alloc=std::allocator<unsigned char> >
+struct bit_aligned_image1_type { typedef ... type; };
 
 template <unsigned Size1, unsigned Size2,
-        typename Layout, typename Alloc=std::allocator<unsigned char> >
-struct bit_aligned_image2_type { typedef ... type; };
+        typename Layout, typename Alloc=std::allocator<unsigned char> >
+struct bit_aligned_image2_type { typedef ... type; };
 
 template <unsigned Size1, unsigned Size2, unsigned Size3,
-        typename Layout, typename Alloc=std::allocator<unsigned char> >
-struct bit_aligned_image3_type { typedef ... type; };
+        typename Layout, typename Alloc=std::allocator<unsigned char> >
+struct bit_aligned_image3_type { typedef ... type; };
 
 template <unsigned Size1, unsigned Size2, unsigned Size3, unsigned Size4,
-        typename Layout, typename Alloc=std::allocator<unsigned char> >
-struct bit_aligned_image4_type { typedef ... type; };
+        typename Layout, typename Alloc=std::allocator<unsigned char> >
+struct bit_aligned_image4_type { typedef ... type; };
 
 template <unsigned Size1, unsigned Size2, unsigned Size3, unsigned Size4, unsigned Size5,
-        typename Layout, typename Alloc=std::allocator<unsigned char> >
-struct bit_aligned_image5_type { typedef ... type; };
+        typename Layout, typename Alloc=std::allocator<unsigned char> >
+struct bit_aligned_image5_type { typedef ... type; };
 

 

 

@@ -190,17 +190,17 @@ bit-aligned images with up to five channels:

 IsYStep because GIL’s memory-based locator and view already allow
 the vertical step to be specified dynamically. Iterators and views can
 be constructed from a pixel type:

-
template <typename Pixel, bool IsPlanar=false, bool IsStep=false, bool IsMutable=true>
-struct iterator_type_from_pixel { typedef ... type; };
+
template <typename Pixel, bool IsPlanar=false, bool IsStep=false, bool IsMutable=true>
+struct iterator_type_from_pixel { typedef ... type; };
 
-template <typename Pixel, bool IsPlanar=false, bool IsStepX=false, bool IsMutable=true>
-struct view_type_from_pixel { typedef ... type; };
+template <typename Pixel, bool IsPlanar=false, bool IsStepX=false, bool IsMutable=true>
+struct view_type_from_pixel { typedef ... type; };
 

 

 
Using a heterogeneous pixel type will result in heterogeneous iterators and
 views. Types can also be constructed from horizontal iterator:

-
template <typename XIterator>
-struct type_from_x_iterator
+
template <typename XIterator>
+struct type_from_x_iterator
 {
   typedef ... step_iterator_t;
   typedef ... xy_locator_t;
@@ -215,13 +215,13 @@ views. Types can also be constructed from horizontal iterator:

 iterators, locators and views) using the following metafunctions provided by
 PixelBasedConcept, HomogeneousPixelBasedConcept and metafunctions
 built on top of them:

-
template <typename T> struct color_space_type { typedef ... type; };
-template <typename T> struct channel_mapping_type { typedef ... type; };
-template <typename T> struct is_planar { typedef ... type; };
+
template <typename T> struct color_space_type { typedef ... type; };
+template <typename T> struct channel_mapping_type { typedef ... type; };
+template <typename T> struct is_planar { typedef ... type; };
 
 // Defined by homogeneous constructs
-template <typename T> struct channel_type { typedef ... type; };
-template <typename T> struct num_channels { typedef ... type; };
+template <typename T> struct channel_type { typedef ... type; };
+template <typename T> struct num_channels { typedef ... type; };
 

 

 

@@ -229,30 +229,30 @@ built on top of them:

 
Deriving and manipulating existing types

 
There are metafunctions to construct the type of a construct from an existing
 type by changing one or more of its properties:

-
template <typename PixelReference,
-        typename ChannelValue, typename Layout, typename IsPlanar, typename IsMutable>
-struct derived_pixel_reference_type
+
template <typename PixelReference,
+        typename ChannelValue, typename Layout, typename IsPlanar, typename IsMutable>
+struct derived_pixel_reference_type
 {
   typedef ... type;  // Models PixelConcept
 };
 
-template <typename Iterator,
-        typename ChannelValue, typename Layout, typename IsPlanar, typename IsStep, typename IsMutable>
-struct derived_iterator_type
+template <typename Iterator,
+        typename ChannelValue, typename Layout, typename IsPlanar, typename IsStep, typename IsMutable>
+struct derived_iterator_type
 {
   typedef ... type;  // Models PixelIteratorConcept
 };
 
-template <typename View,
-        typename ChannelValue, typename Layout, typename IsPlanar, typename IsXStep, typename IsMutable>
-struct derived_view_type
+template <typename View,
+        typename ChannelValue, typename Layout, typename IsPlanar, typename IsXStep, typename IsMutable>
+struct derived_view_type
 {
   typedef ... type;  // Models ImageViewConcept
 };
 
-template <typename Image,
-        typename ChannelValue, typename Layout, typename IsPlanar>
-struct derived_image_type
+template <typename Image,
+        typename ChannelValue, typename Layout, typename IsPlanar>
+struct derived_image_type
 {
   typedef ... type;  // Models ImageConcept
 };
@@ -262,7 +262,7 @@ type by changing one or more of its properties:

 for the rest. In this case IsPlanar, IsStep and IsMutable are
 MPL boolean constants. For example, here is how to create the type of a view
 just like View, but being grayscale and planar:

-
using VT = typename derived_view_type<View, boost::use_default, gray_t, mpl::true_>::type;
+
using VT = typename derived_view_type<View, boost::use_default, gray_t, mpl::true_>::type;
 

 

 

@@ -302,8 +302,8 @@ is basic, but a color converted view or a virtual view is not.

     

     

     
   
 
\ No newline at end of file
diff --git a/develop/doc/html/design/pixel.html b/develop/doc/html/design/pixel.html
index 390f2101d..fdce63a36 100644
--- a/develop/doc/html/design/pixel.html
+++ b/develop/doc/html/design/pixel.html
@@ -95,37 +95,37 @@ compatible pixels.

 iterators, locators, views and images) must provide metafunctions to
 access their color space, channel mapping, number of channels, and
 (for homogeneous pixels) the channel type:

-
concept PixelBasedConcept<typename T>
+
concept PixelBasedConcept<typename T>
 {
-  typename color_space_type<T>;
+  typename color_space_type<T>;
       where Metafunction<color_space_type<T> >;
       where ColorSpaceConcept<color_space_type<T>::type>;
-  typename channel_mapping_type<T>;
+  typename channel_mapping_type<T>;
       where Metafunction<channel_mapping_type<T> >;
       where ChannelMappingConcept<channel_mapping_type<T>::type>;
-  typename is_planar<T>;
+  typename is_planar<T>;
       where Metafunction<is_planar<T> >;
       where SameType<is_planar<T>::type, bool>;
 };
 
-concept HomogeneousPixelBasedConcept<PixelBasedConcept T>
+concept HomogeneousPixelBasedConcept<PixelBasedConcept T>
 {
-  typename channel_type<T>;
+  typename channel_type<T>;
       where Metafunction<channel_type<T> >;
       where ChannelConcept<channel_type<T>::type>;
 };
 

 

 
Pixels model the following concepts:

-
concept PixelConcept<typename P> : ColorBaseConcept<P>, PixelBasedConcept<P>
+
concept PixelConcept<typename P> : ColorBaseConcept<P>, PixelBasedConcept<P>
 {
   where is_pixel<P>::value==true;
   // where for each K [0..size<P>::value-1]:
   //      ChannelConcept<kth_element_type<K> >;
 
-  typename value_type;       where PixelValueConcept<value_type>;
-  typename reference;        where PixelConcept<reference>;
-  typename const_reference;  where PixelConcept<const_reference>;
+  typename value_type;       where PixelValueConcept<value_type>;
+  typename reference;        where PixelConcept<reference>;
+  typename const_reference;  where PixelConcept<const_reference>;
   static const bool P::is_mutable;
 
   template <PixelConcept P2> where { PixelConcept<P,P2> }
@@ -136,27 +136,27 @@ access their color space, channel mapping, number of channels, and
       bool operator!=(const P&, const P2&);
 };
 
-concept MutablePixelConcept<typename P> : PixelConcept<P>, MutableColorBaseConcept<P>
+concept MutablePixelConcept<typename P> : PixelConcept<P>, MutableColorBaseConcept<P>
 {
   where is_mutable==true;
 };
 
-concept HomogeneousPixelConcept<PixelConcept P> : HomogeneousColorBaseConcept<P>, HomogeneousPixelBasedConcept<P>
+concept HomogeneousPixelConcept<PixelConcept P> : HomogeneousColorBaseConcept<P>, HomogeneousPixelBasedConcept<P>
 {
-  P::template element_const_reference_type<P>::type operator[](P p, std::size_t i) const { return dynamic_at_c(P,i); }
+  P::template element_const_reference_type<P>::type operator[](P p, std::size_t i) const { return dynamic_at_c(P,i); }
 };
 
-concept MutableHomogeneousPixelConcept<MutablePixelConcept P> : MutableHomogeneousColorBaseConcept<P>
+concept MutableHomogeneousPixelConcept<MutablePixelConcept P> : MutableHomogeneousColorBaseConcept<P>
 {
-  P::template element_reference_type<P>::type operator[](P p, std::size_t i) { return dynamic_at_c(p,i); }
+  P::template element_reference_type<P>::type operator[](P p, std::size_t i) { return dynamic_at_c(p,i); }
 };
 
-concept PixelValueConcept<typename P> : PixelConcept<P>, Regular<P>
+concept PixelValueConcept<typename P> : PixelConcept<P>, Regular<P>
 {
   where SameType<value_type,P>;
 };
 
-concept PixelsCompatibleConcept<PixelConcept P1, PixelConcept P2> : ColorBasesCompatibleConcept<P1,P2>
+concept PixelsCompatibleConcept<PixelConcept P1, PixelConcept P2> : ColorBasesCompatibleConcept<P1,P2>
 {
   // where for each K [0..size<P1>::value):
   //    ChannelsCompatibleConcept<kth_semantic_element_type<P1,K>::type, kth_semantic_element_type<P2,K>::type>;
@@ -169,9 +169,9 @@ an explicit, non-symmetric and often lossy operation (due to both
 channel and color space approximation). Convertibility requires
 modeling the following concept:

 
template <PixelConcept SrcPixel, MutablePixelConcept DstPixel>
-concept PixelConvertibleConcept
+concept PixelConvertibleConcept
 {
-  void color_convert(const SrcPixel&, DstPixel&);
+  void color_convert(const SrcPixel&, DstPixel&);
 };
 

 

@@ -199,7 +199,7 @@ both, but only pixel values model the latter.

 together in memory. For this purpose GIL provides the struct
 pixel, templated over the channel value and layout:

 
// models HomogeneousPixelValueConcept
-template <typename ChannelValue, typename Layout> struct pixel;
+template <typename ChannelValue, typename Layout> struct pixel;
 
 // Those typedefs are already provided by GIL
 typedef pixel<bits8, rgb_layout_t> rgb8_pixel_t;
@@ -222,7 +222,7 @@ same value type (pi
 proxy class containing references to each of the channels.
 This is implemented with the struct planar_pixel_reference:

 
// models HomogeneousPixel
-template <typename ChannelReference, typename ColorSpace> struct planar_pixel_reference;
+template <typename ChannelReference, typename ColorSpace> struct planar_pixel_reference;
 
 // Define the type of a mutable and read-only reference. (These typedefs are already provided by GIL)
 typedef planar_pixel_reference<      bits8&,rgb_t> rgb8_planar_ref_t;
@@ -348,8 +348,8 @@ different color spaces and channel types:

     

     

     
   
 
\ No newline at end of file
diff --git a/develop/doc/html/design/pixel_iterator.html b/develop/doc/html/design/pixel_iterator.html
index 02dc9cf04..0ad3cec5a 100644
--- a/develop/doc/html/design/pixel_iterator.html
+++ b/develop/doc/html/design/pixel_iterator.html
@@ -104,18 +104,18 @@
 (i.e. whether they allow for modifying the pixel they refer to), to get the
 immutable (read-only) type of the iterator, and to determine whether they are
 plain iterators or adaptors over another pixel iterator:

-
concept PixelIteratorConcept<RandomAccessTraversalIteratorConcept Iterator>
+
concept PixelIteratorConcept<RandomAccessTraversalIteratorConcept Iterator>
     : PixelBasedConcept<Iterator>
 {
   where PixelValueConcept<value_type>;
-  typename const_iterator_type<It>::type;
+  typename const_iterator_type<It>::type;
       where PixelIteratorConcept<const_iterator_type<It>::type>;
   static const bool  iterator_is_mutable<It>::value;
   static const bool  is_iterator_adaptor<It>::value;   // is it an iterator adaptor
 };
 
-template <typename Iterator>
-concept MutablePixelIteratorConcept : PixelIteratorConcept<Iterator>, MutableRandomAccessIteratorConcept<Iterator> {};
+template <typename Iterator>
+concept MutablePixelIteratorConcept : PixelIteratorConcept<Iterator>, MutableRandomAccessIteratorConcept<Iterator> {};
 

 

 

@@ -135,8 +135,8 @@ over interleaved packed pixels.

 planar_pixel_iterator, templated over a channel iterator and color space.
 Here is how the standard mutable and read-only planar RGB iterators over
 unsigned char are defined:

-
template <typename ChannelPtr, typename ColorSpace>
-struct planar_pixel_iterator;
+
template <typename ChannelPtr, typename ColorSpace>
+struct planar_pixel_iterator;
 
 // GIL provided typedefs
 typedef planar_pixel_iterator<const bits8*, rgb_t> rgb8c_planar_ptr_t;
@@ -148,13 +148,13 @@ subclasses from hom
 algorithms apply to it. The element type of its color base is a channel
 iterator. For example, GIL implements operator++ of planar iterators
 approximately like this:

-
template <typename T>
-struct inc : public std::unary_function<T,T>
+
template <typename T>
+struct inc : public std::unary_function<T,T>
 {
-  T operator()(T x) const { return ++x; }
+  T operator()(T x) const { return ++x; }
 };
 
-template <typename ChannelPtr, typename ColorSpace>
+template <typename ChannelPtr, typename ColorSpace>
 planar_pixel_iterator<ChannelPtr,ColorSpace>&
 planar_pixel_iterator<ChannelPtr,ColorSpace>::operator++()
 {
@@ -176,16 +176,16 @@ byte and the bit offset.

 is_iterator_adaptor metafunction must evaluate to true, and it needs to
 provide a member method to return the base iterator, a metafunction to get its
 type, and a metafunction to rebind to another base iterator:

-
concept IteratorAdaptorConcept<RandomAccessTraversalIteratorConcept Iterator>
+
concept IteratorAdaptorConcept<RandomAccessTraversalIteratorConcept Iterator>
 {
   where SameType<is_iterator_adaptor<Iterator>::type, mpl::true_>;
 
-  typename iterator_adaptor_get_base<Iterator>;
+  typename iterator_adaptor_get_base<Iterator>;
       where Metafunction<iterator_adaptor_get_base<Iterator> >;
       where boost_concepts::ForwardTraversalConcept<iterator_adaptor_get_base<Iterator>::type>;
 
-  typename another_iterator;
-  typename iterator_adaptor_rebind<Iterator,another_iterator>::type;
+  typename another_iterator;
+  typename iterator_adaptor_rebind<Iterator,another_iterator>::type;
       where boost_concepts::ForwardTraversalConcept<another_iterator>;
       where IteratorAdaptorConcept<iterator_adaptor_rebind<Iterator,another_iterator>::type>;
 
@@ -193,7 +193,7 @@ type, and a metafunction to rebind to another base iterator:

 };
 
 template <boost_concepts::Mutable_ForwardIteratorConcept Iterator>
-concept MutableIteratorAdaptorConcept : IteratorAdaptorConcept<Iterator> {};
+concept MutableIteratorAdaptorConcept : IteratorAdaptorConcept<Iterator> {};
 

 

 

@@ -225,15 +225,15 @@ model PixelDerefere
 dereferencing a pixel iterator. Its argument type could be anything (usually a
 PixelConcept) and the result type must be convertible to PixelConcept:

 
template <boost::UnaryFunctionConcept D>
-concept PixelDereferenceAdaptorConcept:
+concept PixelDereferenceAdaptorConcept:
     DefaultConstructibleConcept<D>,
     CopyConstructibleConcept<D>,
     AssignableConcept<D>
 {
-  typename const_t;         where PixelDereferenceAdaptorConcept<const_t>;
-  typename value_type;      where PixelValueConcept<value_type>;
-  typename reference;       where PixelConcept<remove_reference<reference>::type>;  // may be mutable
-  typename const_reference;   // must not be mutable
+  typename const_t;         where PixelDereferenceAdaptorConcept<const_t>;
+  typename value_type;      where PixelValueConcept<value_type>;
+  typename reference;       where PixelConcept<remove_reference<reference>::type>;  // may be mutable
+  typename const_reference;   // must not be mutable
   static const bool D::is_mutable;
 
   where Convertible<value_type, result_type>;
@@ -275,12 +275,12 @@ useful:

 
 
Step iterators are forward traversal iterators that allow changing the step
 between adjacent values:

-
concept StepIteratorConcept<boost_concepts::ForwardTraversalConcept Iterator>
+
concept StepIteratorConcept<boost_concepts::ForwardTraversalConcept Iterator>
 {
   template <Integral D> void Iterator::set_step(D step);
 };
 
-concept MutableStepIteratorConcept<boost_concepts::Mutable_ForwardIteratorConcept Iterator>
+concept MutableStepIteratorConcept<boost_concepts::Mutable_ForwardIteratorConcept Iterator>
     : StepIteratorConcept<Iterator>
 {};
 

@@ -300,26 +300,26 @@ in memunits away. It must also supply a function that advances an iterator a
 given distance in memory units. memunit_advanced and
 memunit_advanced_ref have a default implementation but some iterators may
 supply a more efficient version:

-
concept MemoryBasedIteratorConcept
+
concept MemoryBasedIteratorConcept
 <
     boost_concepts::RandomAccessTraversalConcept Iterator
 >
 {
-  typename byte_to_memunit<Iterator>; where metafunction<byte_to_memunit<Iterator> >;
+  typename byte_to_memunit<Iterator>; where metafunction<byte_to_memunit<Iterator> >;
   std::ptrdiff_t      memunit_step(const Iterator&);
   std::ptrdiff_t      memunit_distance(const Iterator& , const Iterator&);
   void                memunit_advance(Iterator&, std::ptrdiff_t diff);
   Iterator            memunit_advanced(const Iterator& p, std::ptrdiff_t diff) { Iterator tmp; memunit_advance(tmp,diff); return tmp; }
-  Iterator::reference memunit_advanced_ref(const Iterator& p, std::ptrdiff_t diff) { return *memunit_advanced(p,diff); }
+  Iterator::reference memunit_advanced_ref(const Iterator& p, std::ptrdiff_t diff) { return *memunit_advanced(p,diff); }
 };
 

 

 
It is useful to be able to construct a step iterator over another iterator.
 More generally, given a type, we want to be able to construct an equivalent
 type that allows for dynamically specified horizontal step:

-
concept HasDynamicXStepTypeConcept<typename T>
+
concept HasDynamicXStepTypeConcept<typename T>
 {
-  typename dynamic_x_step_type<T>;
+  typename dynamic_x_step_type<T>;
       where Metafunction<dynamic_x_step_type<T> >;
 };
 

@@ -348,8 +348,8 @@ number of memory units (bytes or bits) to skip for a unit step. It may also be
 used with a negative number. GIL provides a function to create a step iterator
 from a base iterator and a step:

 
// Iterator models MemoryBasedIteratorConcept, HasDynamicXStepTypeConcept
-template <typename Iterator>
-typename dynamic_x_step_type<Iterator>::type make_step_iterator(Iterator const& it, std::ptrdiff_t step);
+template <typename Iterator>
+typename dynamic_x_step_type<Iterator>::type make_step_iterator(Iterator const& it, std::ptrdiff_t step);
 

 

 
GIL also provides a model of an iterator over a virtual array of pixels,
@@ -372,8 +372,8 @@ but not MemoryBased
     

     

     
   
 
\ No newline at end of file
diff --git a/develop/doc/html/design/pixel_locator.html b/develop/doc/html/design/pixel_locator.html
index 01ca78b12..808bcb0d6 100644
--- a/develop/doc/html/design/pixel_locator.html
+++ b/develop/doc/html/design/pixel_locator.html
@@ -83,30 +83,30 @@ don’t satisfy all the requirements of iterators. For example, they don’t
 supply increment and decrement operators because it is unclear which dimension
 the operators should advance along.
 N-dimensional locators model the following concept:

-
concept RandomAccessNDLocatorConcept<Regular Loc>
+
concept RandomAccessNDLocatorConcept<Regular Loc>
 {
-  typename value_type;        // value over which the locator navigates
-  typename reference;         // result of dereferencing
-  typename difference_type; where PointNDConcept<difference_type>; // return value of operator-.
-  typename const_t;           // same as Loc, but operating over immutable values
-  typename cached_location_t; // type to store relative location (for efficient repeated access)
-  typename point_t  = difference_type;
+  typename value_type;        // value over which the locator navigates
+  typename reference;         // result of dereferencing
+  typename difference_type; where PointNDConcept<difference_type>; // return value of operator-.
+  typename const_t;           // same as Loc, but operating over immutable values
+  typename cached_location_t; // type to store relative location (for efficient repeated access)
+  typename point_t  = difference_type;
 
   static const size_t num_dimensions; // dimensionality of the locator
   where num_dimensions = point_t::num_dimensions;
 
   // The difference_type and iterator type along each dimension. The iterators may only differ in
   // difference_type. Their value_type must be the same as Loc::value_type
-  template <size_t D> struct axis {
-      typename coord_t = point_t::axis<D>::coord_t;
-      typename iterator; where RandomAccessTraversalConcept<iterator>; // iterator along D-th axis.
+  template <size_t D> struct axis {
+      typename coord_t = point_t::axis<D>::coord_t;
+      typename iterator; where RandomAccessTraversalConcept<iterator>; // iterator along D-th axis.
       where iterator::value_type == value_type;
   };
 
   // Defines the type of a locator similar to this type, except it invokes Deref upon dereferencing
-  template <PixelDereferenceAdaptorConcept Deref> struct add_deref {
-      typename type;        where RandomAccessNDLocatorConcept<type>;
-      static type make(const Loc& loc, const Deref& deref);
+  template <PixelDereferenceAdaptorConcept Deref> struct add_deref {
+      typename type;        where RandomAccessNDLocatorConcept<type>;
+      static type make(const Loc& loc, const Deref& deref);
   };
 
   Loc& operator+=(Loc&, const difference_type&);
@@ -127,24 +127,24 @@ N-dimensional locators model the following concept:

   template <size_t D> axis<D>::iterator        Loc::axis_iterator(const difference_type&) const;
 };
 
-template <typename Loc>
-concept MutableRandomAccessNDLocatorConcept
-    : RandomAccessNDLocatorConcept<Loc>
+template <typename Loc>
+concept MutableRandomAccessNDLocatorConcept
+    : RandomAccessNDLocatorConcept<Loc>
 {
   where Mutable<reference>;
 };
 

 

 
Two-dimensional locators have additional requirements:

-
concept RandomAccess2DLocatorConcept<RandomAccessNDLocatorConcept Loc>
+
concept RandomAccess2DLocatorConcept<RandomAccessNDLocatorConcept Loc>
 {
   where num_dimensions==2;
   where Point2DConcept<point_t>;
 
-  typename x_iterator = axis<0>::iterator;
-  typename y_iterator = axis<1>::iterator;
-  typename x_coord_t  = axis<0>::coord_t;
-  typename y_coord_t  = axis<1>::coord_t;
+  typename x_iterator = axis<0>::iterator;
+  typename y_iterator = axis<1>::iterator;
+  typename x_coord_t  = axis<0>::coord_t;
+  typename y_coord_t  = axis<1>::coord_t;
 
   // Only available to locators that have dynamic step in Y
   //Loc::Loc(const Loc& loc, y_coord_t);
@@ -172,16 +172,16 @@ N-dimensional locators model the following concept:

   y_coord_t Loc::y_distance_to(const Loc& loc2, x_coord_t x_diff) const;
 };
 
-concept MutableRandomAccess2DLocatorConcept<RandomAccess2DLocatorConcept Loc>
+concept MutableRandomAccess2DLocatorConcept<RandomAccess2DLocatorConcept Loc>
     : MutableRandomAccessNDLocatorConcept<Loc> {};
 

 

 
2D locators can have a dynamic step not just horizontally, but
 vertically. This gives rise to the Y equivalent of
 HasDynamicXStepTypeConcept:

-
concept HasDynamicYStepTypeConcept<typename T>
+
concept HasDynamicYStepTypeConcept<typename T>
 {
-  typename dynamic_y_step_type<T>;
+  typename dynamic_y_step_type<T>;
       where Metafunction<dynamic_y_step_type<T> >;
 };
 

@@ -191,9 +191,9 @@ vertically. This gives rise to the Y equivalent of
 
Sometimes it is necessary to swap the meaning of X and Y for a given locator
 or image view type (for example, GIL provides a function to transpose an image
 view). Such locators and views must be transposable:

-
concept HasTransposedTypeConcept<typename T>
+
concept HasTransposedTypeConcept<typename T>
 {
-  typename transposed_type<T>;
+  typename transposed_type<T>;
       where Metafunction<transposed_type<T> >;
 };
 

@@ -201,17 +201,17 @@ view). Such locators and views must be transposable:

 
All GIL provided locators and views model HasTransposedTypeConcept.

 
The locators GIL uses operate over models of PixelConcept and their x and
 y dimension types are the same. They model the following concept:

-
concept PixelLocatorConcept<RandomAccess2DLocatorConcept Loc>
+
concept PixelLocatorConcept<RandomAccess2DLocatorConcept Loc>
 {
   where PixelValueConcept<value_type>;
   where PixelIteratorConcept<x_iterator>;
   where PixelIteratorConcept<y_iterator>;
   where x_coord_t == y_coord_t;
 
-  typename coord_t = x_coord_t;
+  typename coord_t = x_coord_t;
 };
 
-concept MutablePixelLocatorConcept<PixelLocatorConcept Loc> : MutableRandomAccess2DLocatorConcept<Loc> {};
+concept MutablePixelLocatorConcept<PixelLocatorConcept Loc> : MutableRandomAccess2DLocatorConcept<Loc> {};
 

 

 

@@ -237,7 +237,7 @@ that have their pixels in memory. It takes a model of MutableStepIteratorConcept, it models MutablePixelLocatorConcept).

 
// StepIterator models StepIteratorConcept, MemoryBasedIteratorConcept
-template <typename StepIterator>
+template <typename StepIterator>
 class memory_based_2d_locator;
 

 

@@ -287,12 +287,12 @@ required by PixelLo
 they need to provide other models of PixelLocatorConcept.

 
Here is some sample code using locators:

 
loc=img.xy_at(10,10);            // start at pixel (x=10,y=10)
-above=loc.cache_location(0,-1);  // remember relative locations of neighbors above and below
+above=loc.cache_location(0,-1);  // remember relative locations of neighbors above and below
 below=loc.cache_location(0, 1);
 ++loc.x();                       // move to (11,10)
 loc.y()+=15;                     // move to (11,25)
 loc-=point<std::ptrdiff_t>(1,1);// move to (10,24)
-*loc=(loc(0,-1)+loc(0,1))/2;     // set pixel (10,24) to the average of (10,23) and (10,25) (grayscale pixels only)
+*loc=(loc(0,-1)+loc(0,1))/2;     // set pixel (10,24) to the average of (10,23) and (10,25) (grayscale pixels only)
 *loc=(loc[above]+loc[below])/2;  // the same, but faster using cached relative neighbor locations
 

 

@@ -317,7 +317,7 @@ the natural memory-friendly order left-to-right inside
 top-to-bottom. It takes a locator, the width of the image and the
 current X position. This is sufficient information for it to determine
 when to do a “carriage return”. Synopsis:

-
template <typename Locator>  // Models PixelLocatorConcept
+
template <typename Locator>  // Models PixelLocatorConcept
 class iterator_from_2d
 {
 public:
@@ -358,8 +358,8 @@ using the x-iterators directly.

     

     

     
   
 
\ No newline at end of file
diff --git a/develop/doc/html/design/point.html b/develop/doc/html/design/point.html
index 45e480c11..15400e870 100644
--- a/develop/doc/html/design/point.html
+++ b/develop/doc/html/design/point.html
@@ -79,27 +79,27 @@
 
A point defines the location of a pixel inside an image. It can also be used
 to describe the dimensions of an image. In most general terms, points are
 N-dimensional and model the following concept:

-
concept PointNDConcept<typename T> : Regular<T>
+
concept PointNDConcept<typename T> : Regular<T>
 {
     // the type of a coordinate along each axis
-    template <size_t K> struct axis; where Metafunction<axis>;
+    template <size_t K> struct axis; where Metafunction<axis>;
 
     const size_t num_dimensions;
 
     // accessor/modifier of the value of each axis.
-    template <size_t K> const typename axis<K>::type& T::axis_value() const;
-    template <size_t K>       typename axis<K>::type& T::axis_value();
+    template <size_t K> const typename axis<K>::type& T::axis_value() const;
+    template <size_t K>       typename axis<K>::type& T::axis_value();
 };
 

 

 
GIL uses a two-dimensional point, which is a refinement of PointNDConcept
 in which both dimensions are of the same type:

-
concept Point2DConcept<typename T> : PointNDConcept<T>
+
concept Point2DConcept<typename T> : PointNDConcept<T>
 {
     where num_dimensions == 2;
     where SameType<axis<0>::type, axis<1>::type>;
 
-    typename value_type = axis<0>::type;
+    typename value_type = axis<0>::type;
 
     const value_type& operator[](const T&, size_t i);
         value_type& operator[](      T&, size_t i);
@@ -134,8 +134,8 @@ coordinate type.

     

     

     
   
 
\ No newline at end of file
diff --git a/develop/doc/html/design/technicalities.html b/develop/doc/html/design/technicalities.html
index e51265be7..f15b61a59 100644
--- a/develop/doc/html/design/technicalities.html
+++ b/develop/doc/html/design/technicalities.html
@@ -81,16 +81,16 @@ a planar pixel (pla
 references. Writing a reference proxy class can be tricky. One problem
 is that the proxy reference is constructed as a temporary object and
 returned by value upon dereferencing the iterator:

-
struct rgb_planar_pixel_iterator
+
struct rgb_planar_pixel_iterator
 {
  typedef my_reference_proxy<T> reference;
- reference operator*() const { return reference(red,green,blue); }
+ reference operator*() const { return reference(red,green,blue); }
 };
 

 

 
The problem arises when an iterator is dereferenced directly into a
 function that takes a mutable pixel:

-
template <typename Pixel>    // Models MutablePixelConcept
+
template <typename Pixel>    // Models MutablePixelConcept
 void invert_pixel(Pixel& p);
 
 rgb_planar_pixel_iterator myIt;
@@ -102,8 +102,8 @@ reference. The solution is to:

 
    
 
  • Use const qualifier on all members of the reference proxy object:
    • 
 

-
template <typename T>
-struct my_reference_proxy
+
template <typename T>
+struct my_reference_proxy
 {
   const my_reference_proxy& operator=(const my_reference_proxy& p) const;
   const my_reference_proxy* operator->() const { return this; }
@@ -116,7 +116,7 @@ reference. The solution is to:

 (maybe based on the constness of the template parameter)

 
  • Define the reference type of your iterator with const qualifier:
    • 
 
-
    struct iterator_traits<rgb_planar_pixel_iterator>
+
    struct iterator_traits<rgb_planar_pixel_iterator>
 {
   typedef const my_reference_proxy<T> reference;
 };
@@ -131,7 +131,7 @@ way for these STL algorithms to use your overload is if you define it
 in the std namespace:
    
 
    namespace std
 {
- template <typename T>
+ template <typename T>
  void swap(my_reference_proxy<T>& x, my_reference_proxy<T>& y)
  {
     my_value<T> tmp=x;
@@ -159,8 +159,8 @@ suggesting the above solution.
    
     
    
     
    
     
   
 
\ No newline at end of file
diff --git a/develop/doc/html/genindex.html b/develop/doc/html/genindex.html
index 10677b868..86e1a17f7 100644
--- a/develop/doc/html/genindex.html
+++ b/develop/doc/html/genindex.html
@@ -75,8 +75,8 @@
     
    
     
    
     
   
 
\ No newline at end of file
diff --git a/develop/doc/html/image_processing/affine-region-detectors.html b/develop/doc/html/image_processing/affine-region-detectors.html
index 39b55f9b1..bfac20268 100644
--- a/develop/doc/html/image_processing/affine-region-detectors.html
+++ b/develop/doc/html/image_processing/affine-region-detectors.html
@@ -162,8 +162,8 @@ detector.” In Alvey vision conference, vol. 15, no. 50, pp. 10-5244.
     
    
     
    
     
   
 
\ No newline at end of file
diff --git a/develop/doc/html/image_processing/basics.html b/develop/doc/html/image_processing/basics.html
index 2c633e680..2a181ee69 100644
--- a/develop/doc/html/image_processing/basics.html
+++ b/develop/doc/html/image_processing/basics.html
@@ -123,8 +123,8 @@ gets sharper depending on it’s sigma value.
    
     
    
     
    
     
   
 
\ No newline at end of file
diff --git a/develop/doc/html/image_processing/index.html b/develop/doc/html/image_processing/index.html
index 1793e65a1..2c187e7fb 100644
--- a/develop/doc/html/image_processing/index.html
+++ b/develop/doc/html/image_processing/index.html
@@ -99,8 +99,8 @@ features, structures and algorithms, for image processing and analysis.
    
     
    
     
    
     
   
 
\ No newline at end of file
diff --git a/develop/doc/html/image_processing/overview.html b/develop/doc/html/image_processing/overview.html
index 49b1f8cdb..a637e43ef 100644
--- a/develop/doc/html/image_processing/overview.html
+++ b/develop/doc/html/image_processing/overview.html
@@ -88,8 +88,8 @@ projects run in frame of the Google Summer of Code 2019:
    
     
    
     
    
     
   
 
\ No newline at end of file
diff --git a/develop/doc/html/index.html b/develop/doc/html/index.html
index dbf34ba41..ab1dcdd1f 100644
--- a/develop/doc/html/index.html
+++ b/develop/doc/html/index.html
@@ -178,8 +178,8 @@ Blurring images (requires the optional Numeric extension)
    
     
    
     
    
     
   
 
\ No newline at end of file
diff --git a/develop/doc/html/installation.html b/develop/doc/html/installation.html
index f080d1f40..9442436da 100644
--- a/develop/doc/html/installation.html
+++ b/develop/doc/html/installation.html
@@ -90,8 +90,8 @@ where to find Boost and GIL headers should be sufficient for most projects.
    
     
    
     
    
     
   
 
\ No newline at end of file
diff --git a/develop/doc/html/io.html b/develop/doc/html/io.html
index 2f9db4899..5fa528735 100644
--- a/develop/doc/html/io.html
+++ b/develop/doc/html/io.html
@@ -302,7 +302,7 @@ The scanline_read_i
 The following code sample shows the usage:
    
 
    typedef tiff_tag tag_t;
 
-typedef scanline_reader< typename get_read_device< const char*
+typedef scanline_reader< typename get_read_device< const char*
                                                  , tag_t
                                                  >::type
                         , tag_t
@@ -602,26 +602,26 @@ implementations and then trying to follow a couple of guidelines:
    
 
 
  • Add the code to the boost::gil::detail namespace
    • 
 
  • Create a tag type for the new format. Like this:
    
-
    struct xxx_tag : format_tag {};
+
    struct xxx_tag : format_tag {};
 
    
 
    
 
    • 
 
  • Create the image_read_info for the new format. It contains all the
 information that are necessary to read an image. It should be filled
 and returned by the get_info member of the reader class. See below:
    
-
    template<> struct image_read_info< xxx_tag > {};
+
    template<> struct image_read_info< xxx_tag > {};
 
    
 
    
 
    • 
 
  • Create the image_write_info for the new format. It contains all the
 information that are necessary to write an image:
    
-
    template<> struct image_write_info< xxx_tag > {};
+
    template<> struct image_write_info< xxx_tag > {};
 
    
 
    
 
    • 
 
  • Use the following reader skeleton as a start:
    
-
    template< typename Device
-        , typename ConversionPolicy
+
    template< typename Device
+        , typename ConversionPolicy
         >
 class reader< Device
             , xxx_tag
@@ -633,7 +633,7 @@ information that are necessary to write an image:
    
 {
 private:
 
-    typedef typename ConversionPolicy::color_converter_type cc_t;
+    typedef typename ConversionPolicy::color_converter_type cc_t;
 
 public:
 
@@ -655,7 +655,7 @@ information that are necessary to write an image:
    
         // your implementation here
     }
 
-    template< typename View >
+    template< typename View >
     void apply( const View& dst_view )
     {
         // your implementation here
@@ -665,7 +665,7 @@ information that are necessary to write an image:
    
 
    
 
    • 
 
  • The writer skeleton:
    
-
    template< typename Device >
+
    template< typename Device >
 class writer< Device
             , xxx_tag
             >
@@ -676,13 +676,13 @@ information that are necessary to write an image:
    
     : out(file)
     {}
 
-    template<typename View>
+    template<typename View>
     void apply( const View& view )
     {
         // your implementation here
     }
 
-    template<typename View>
+    template<typename View>
     void apply( const View&                        view
               , const image_write_info< xxx_tag >& info )
     {
@@ -736,8 +736,8 @@ to enable the tests:
    
     
    
     
    
     
   
 
\ No newline at end of file
diff --git a/develop/doc/html/naming.html b/develop/doc/html/naming.html
index f6978070a..8ce1a6bc6 100644
--- a/develop/doc/html/naming.html
+++ b/develop/doc/html/naming.html
@@ -114,8 +114,8 @@ pixel.
    • 
     
    
     
    
     
   
 
\ No newline at end of file
diff --git a/develop/doc/html/numeric.html b/develop/doc/html/numeric.html
index 8b7c85966..d06ce6b13 100644
--- a/develop/doc/html/numeric.html
+++ b/develop/doc/html/numeric.html
@@ -79,8 +79,8 @@
     
    
     
    
     
   
 
\ No newline at end of file
diff --git a/develop/doc/html/search.html b/develop/doc/html/search.html
index 04b24c3b6..81d84173e 100644
--- a/develop/doc/html/search.html
+++ b/develop/doc/html/search.html
@@ -83,8 +83,8 @@
     
    
     
    
     
   
 
\ No newline at end of file
diff --git a/develop/doc/html/searchindex.js b/develop/doc/html/searchindex.js
index 6a4302789..9660a854e 100644
--- a/develop/doc/html/searchindex.js
+++ b/develop/doc/html/searchindex.js
@@ -1 +1 @@
-Search.setIndex({docnames:["design/basics","design/channel","design/color_base","design/color_space","design/concepts","design/conclusions","design/dynamic_image","design/examples","design/extending","design/image","design/image_view","design/index","design/metafunctions","design/pixel","design/pixel_iterator","design/pixel_locator","design/point","design/technicalities","image_processing/affine-region-detectors","image_processing/basics","image_processing/index","image_processing/overview","index","installation","io","naming","numeric","toolbox","tutorial/gradient","tutorial/histogram","tutorial/video"],envversion:{"sphinx.domains.c":2,"sphinx.domains.changeset":1,"sphinx.domains.citation":1,"sphinx.domains.cpp":3,"sphinx.domains.index":1,"sphinx.domains.javascript":2,"sphinx.domains.math":2,"sphinx.domains.python":2,"sphinx.domains.rst":2,"sphinx.domains.std":1,sphinx:56},filenames:["design/basics.rst","design/channel.rst","design/color_base.rst","design/color_space.rst","design/concepts.rst","design/conclusions.rst","design/dynamic_image.rst","design/examples.rst","design/extending.rst","design/image.rst","design/image_view.rst","design/index.rst","design/metafunctions.rst","design/pixel.rst","design/pixel_iterator.rst","design/pixel_locator.rst","design/point.rst","design/technicalities.rst","image_processing/affine-region-detectors.rst","image_processing/basics.rst","image_processing/index.rst","image_processing/overview.rst","index.rst","installation.rst","io.rst","naming.rst","numeric.rst","toolbox.rst","tutorial/gradient.rst","tutorial/histogram.rst","tutorial/video.rst"],objects:{},objnames:{},objtypes:{},terms:{"0rrgggbb":13,"0x06":13,"0x0c":13,"0x11":13,"0x30":13,"0x60":13,"0x83":13,"0xc1":13,"1000s":18,"100s":18,"100x100":7,"200x200":28,"4x3":0,"50x50":10,"abstract":[0,5,10,22,28],"boolean":[12,28],"byte":[1,9,10,13,14,15,17,22,28],"case":[2,5,7,8,10,12,13,15,18,24,28],"char":[7,9,10,12,13,14,24,28],"class":[1,2,4,6,8,9,10,12,13,14,15,17,24,28],"const":[1,2,6,7,8,9,10,12,13,14,15,16,17,24,25,28,29],"default":[1,3,6,7,8,9,10,12,14,17,25,28],"final":[2,7,8,28],"float":[1,7,12,24,25,28],"function":[2,6,8,10,12,14,15,17,18,22,24,28,29],"import":[6,9,17,24],"int":[1,2,3,7,10,13,15,24,28,29],"long":[4,7,8,10,12,28],"new":[5,28,29],"public":[6,8,10,14,15,24],"return":[1,2,4,6,7,8,10,12,13,14,15,17,24,28],"short":[12,24,28,29],"static":[1,2,6,7,8,10,13,14,15,28],"switch":[6,28],"throw":6,"true":[1,2,12,13,14,15,28],"try":[7,24,28],"var":[7,29],"void":[2,4,6,7,8,9,10,13,14,17,24,28,29],"while":[0,1,3,13,15,28],But:24,For:[1,2,3,4,6,7,8,10,12,13,14,15,18,24,25,28,29],Its:[1,2,13,14,28],Not:7,One:[15,17,18,24,28],Such:[1,6,15,28],That:[6,28],The:[0,1,2,3,4,5,6,7,8,9,10,11,13,14,15,17,18,19,20,21,22,23,24,25,27,28,29],Their:[6,15,28],Then:[15,28],There:[0,2,6,12,19,24,28],These:[2,12,13,28],Use:[17,24],Using:[10,12,15,22,29],_bmp_test_fil:24,_concept_:28,_dimens:10,_dst:28,_height:24,_imag:[12,25],_img_siz:28,_info:24,_io_dev:24,_is_:12,_loc:[12,25],_pixel:[10,12,25],_planar:[12,25],_png_test_fil:24,_ptr:[12,25],_ref:[12,25],_scanline_length:24,_step:[12,25],_tiff_graphicsmagick_test_fil:24,_tiff_lib_tiff_test_fil:24,_variants_:28,_view:[12,25],_width:[15,24],abbrevi:28,abgr_layout_t:3,abil:24,abl:[14,24],about:[4,8,15,19,28,30],abov:[0,2,7,10,13,14,15,17,18,19,24,28,29],abraham:17,access:[1,2,3,6,7,8,13,15,24,28],accessor:[2,16],accordingli:8,account:7,achiev:19,acknowledg:22,actual:[8,29],adapt:1,adaptor:[8,10,15],add:[6,8,15,24],add_deref:[8,10,15],add_fs_path_support:24,add_ref_t:8,added:27,adding:[7,24],addit:[1,2,4,6,9,10,14,15,28],addition:28,address:[0,12,13],adjac:[10,14,28],adob:10,advanc:[10,14,15,24,28],advantag:[28,29],advis:24,affin:[20,22],after:[2,28],again:[15,18],against:[17,23],alex:17,algorithm:[0,4,5,6,7,8,9,14,15,17,20,21,22],align:[0,6,9,10,13,14,22,28,29],all:[0,1,2,3,4,6,7,8,10,13,14,15,17,18,24,27,28],alloc:[7,9,10,12,24,28,29],allocator_typ:9,allow:[0,1,2,5,6,8,9,10,12,13,14,15,17,22,24,28],alon:19,along:[10,12,14,15,16,28],alpha:[0,27],alpha_t:3,alreadi:[12,13,24,28],also:[0,1,2,3,7,10,12,13,14,15,16,24,28,29],altern:28,alvei:18,alwai:[13,17,25,28],amount:[14,15],analog:13,analysi:[12,20],andrew:18,ani:[0,2,5,6,7,8,10,12,14,15,18,19,23,28,29],anoth:[1,2,5,6,8,10,13,14,19,24,28],another_iter:14,any_imag:[6,24,28],any_image_view:[6,28],any_pixel:[6,28],any_pixel_iter:[6,28],anyth:[8,14,24],api:22,append:12,appendix:28,appli:[0,1,14,19,22,24,28],applic:[24,28],apply_oper:[6,28],appropri:[1,6,24],approxim:[13,14,28],arbitrari:[8,14,28],area:[7,10,24],aren:24,argb_layout_t:3,argument:[6,14,28],argument_typ:[8,10,28],aris:17,arithmet:[1,19],around:[7,14,15,24],arrai:[0,14,15,19],ascii:24,assembl:28,assert:[1,7,13,28],assert_sam:6,assign:[1,2,4,6,9,13,17,28],assignableconcept:14,associ:[1,2,3,6,12,28],assum:[18,28],at_c:[2,13],atom:28,author:24,auto:[4,24],avaialbl:4,avail:[6,10,15,20,24,28],averag:15,avoid:28,awai:[10,14],axi:[10,15,16,19,28],axis:19,axis_iter:[10,15],axis_valu:16,b16:7,back:[6,10,28],backend:24,backend_t:24,backward:25,bad_cast:6,base:[1,6,10,11,13,14,15,17,22,24,28,29],basic:[4,11,12,18,20,22,24],becam:24,becaus:[1,6,9,10,12,13,15,18,28],been:[5,24,28,29],befor:24,begin:[7,10,24,28,29],behav:6,being:[12,20,24],belong:27,below:[11,14,15,18,20,24,28],berlin:18,besid:[3,24],beta:10,better:28,between:[1,6,8,10,13,14,28],bgr16_view_t:7,bgr16s_pixel_t:28,bgr16s_view_t:28,bgr232:13,bgr232_pixel_t:13,bgr232_ptr_t:13,bgr232_ref_t:13,bgr556:13,bgr556_pixel_t:13,bgr8:13,bgr8_image_t:[12,25],bgr8_pixel_t:[7,13],bgr8_view_t:6,bgr:[0,2,7,12,13,25,28,29],bgr_layout_t:[3,13],bgra_layout_t:3,big:[18,24],biggest:28,bilinear:22,bin:7,binari:[24,28],binaryfunctionconcept:10,bit:[0,1,2,7,8,9,10,13,14,15,24,25,28,29],bit_align:13,bit_aligned_image1_typ:12,bit_aligned_image2_typ:12,bit_aligned_image3_typ:12,bit_aligned_image4_typ:12,bit_aligned_image5_typ:12,bit_aligned_image_typ:12,bit_aligned_pixel_iter:[13,14],bit_aligned_pixel_refer:13,bitdepth:[12,25],bitfield:12,bitmask:22,bits16:1,bits32f:1,bits8:[7,10,13,14,28],bitwis:10,block:[3,10,28],blue:[2,7,13,17],blue_t:[2,3,7,13],blur:[18,22],bmp_filenam:24,bmp_test_fil:24,bmp_wiki:24,bodi:28,bool:[1,2,4,6,8,9,10,12,13,14,15,28],boost:[3,6,7,10,12,14,21,23,24,27,28,29],boost_check_equ:24,boost_concept:14,boost_gil_extension_io_jpeg_c_lib_compiled_as_cplusplu:24,boost_gil_extension_io_png_c_lib_compiled_as_cplusplu:24,boost_gil_extension_io_tiff_c_lib_compiled_as_cplusplu:24,boost_gil_extension_io_zlib_c_lib_compiled_as_cplusplu:24,boost_gil_io_add_fs_path_support:24,boost_gil_io_enable_gray_alpha:24,boost_gil_io_png_1_4_or_low:24,boost_gil_io_png_dithering_support:24,boost_gil_io_png_fixed_point_support:24,boost_gil_io_png_floating_point_support:24,boost_gil_io_test_allow_reading_imag:24,boost_gil_io_test_allow_writing_imag:24,boost_gil_io_use_bmp_test_suite_imag:24,boost_gil_io_use_png_test_suite_imag:24,boost_gil_io_use_pnm_test_suite_imag:24,boost_gil_io_use_tiff_graphicsmagick_test_suite_imag:24,boost_gil_io_use_tiff_libtiff_test_suite_imag:24,boost_gil_use_concept_check:[10,28],boost_mpl_assert:13,boostorg:23,border:7,both:[0,6,7,13,15,16,18,24,28,29],bottom:[0,10,15,28],bound:[6,13],boundari:28,bourdev:30,buffer:[7,13,28],build:[0,24],built:[1,7,12,13,14,23,28],byte_to_memunit:14,c_str:24,cach:[15,28],cache_loc:[15,28],cached_location_t:[15,28],calcul:29,call:[6,7,8,10,13,17,18,24,28,29],can:[2,4,5,6,7,8,9,10,12,13,14,15,16,17,18,19,22,23,24,28,29],cannot:[7,10,19,28],canon:[13,28],capabl:24,captur:3,care:8,carriag:[15,28],cast:28,caus:[18,28],caution:6,cav:6,cb1:2,cb2:2,cb3:2,cc_t:24,ccv:10,ccv_imag:28,center:[7,19],centerimg:7,central:28,certain:19,challeng:[0,28],chan16:1,chang:[6,8,10,12,14,18,24,28,29],channel16_0_5_reference_t:1,channel16_11_5_reference_t:1,channel16_5_6_reference_t:1,channel1:1,channel2:1,channel3:1,channel:[0,2,3,5,6,7,10,11,12,13,14,17,19,22,24,25,28,29],channel_6bit:1,channel_convert:[1,7,8,13,28],channel_convert_to_unsign:28,channel_invert:[1,8],channel_mapping_t:3,channel_mapping_typ:[12,13,28],channel_multipli:1,channel_t:28,channel_trait:[1,8],channel_typ:[7,12,13,27,28],channel_type_to_index:27,channelbitsizevector:12,channelconcept:[1,13],channelconvertibleconcept:1,channelmap:3,channelmappingconcept:[3,13],channelptr:14,channelrefer:13,channelrefvec:14,channelscompatibleconcept:[1,13],channelvalu:[12,13,14],channelvalueconcept:[1,12],check:[6,7,10,15,28],choic:[15,18],choos:15,chose:7,christoph:18,chunki:28,claim:24,classtyp:[12,25],clear:[19,24],client:23,clockwis:28,close:24,closer:28,cmyk16_pixel_t:[12,13,25],cmyk16_planar_image_t:6,cmyk16_planar_step_view_t:6,cmyk16_planar_view_t:6,cmyk16c_planar_ref_t:25,cmyk16c_planar_view_t:6,cmyk16sc_planar_ref_t:12,cmyk8_image_t:24,cmyk:[0,12,25],cmyk_t:3,cmyka:27,code:[0,3,5,6,7,8,10,15,21,22,24,25,29],col:29,col_begin:10,col_end:10,collect:[6,27],color:[0,1,5,6,7,10,11,12,13,14,15,22,24,25,27,29],color_bas:2,color_const_reference_t:2,color_convert:[8,13,27],color_convert_deref_fn:[8,14],color_convert_view:8,color_converted_view:[7,8,10,28,29],color_converted_view_typ:[8,10],color_converter_typ:24,color_reference_t:2,color_spac:27,color_space_t:[2,3],color_space_typ:[7,8,12,13,28],colorbas:2,colorbaseconcept:[2,13],colorbasescompatibleconcept:[2,13],colorbasevalueconcept:2,colorconvert:10,colorspac:[3,12,13,14,25],colorspace1:3,colorspace2:3,colorspaceconcept:[3,13],colorspacescompatibleconcept:[2,3,28],column:[14,15,28,29],com:[10,23,30],combin:[6,14,15,18,28],come:[12,24],commerci:29,common:[0,2,4,6,24],commonli:13,commun:27,compact:1,compactli:[7,28],compar:[0,1,2,5,6,7,28],comparison:[1,6,15,18],compat:[1,2,3,6,7,10,13,24,28],compil:[1,2,5,6,7,10,13,14,17,23,28],complement:5,complet:[24,28],complex:[6,7,13,15,18,28],complic:[8,9,17],compon:[0,1,25],compos:[10,14],comprehend:28,comprehens:28,compris:3,comput:[7,15,18,19,28,29],computexgradientgray8:28,concept:[0,1,2,5,8,9,10,11,13,14,15,16,18,19,22,28],concept_check:[10,28],concept_map:4,conceptc:4,conceptu:13,conclus:[11,22],concret:[6,28],condit:[15,18],confer:18,consid:[1,3,6,13,19,29],consist:[2,15,23,28],const_iterator_typ:14,const_point:1,const_refer:[1,8,10,13,14,28],const_t:[6,8,9,10,14,15,28],const_view:[9,28],const_view_t:[6,9],constant:[10,12,13,17,18,28],constexpr:[8,28],construct:[1,4,5,6,7,8,9,10,12,13,14,17,28],constructor:[1,6,7,9,17,28],consult:24,contain:[1,2,3,6,7,9,13,14,24,28],content:[11,20,27],context:[19,24],contigu:2,conveni:8,convent:[22,28],convers:[1,13,14,15,24],conversionpolici:24,convert:[1,2,7,8,10,12,13,14,24,27,28],convolut:[10,20,22],convolv:[7,19],coord:28,coord_t:[9,10,15],coordin:[15,16,24,28],copi:[1,2,6,7,8,9,10,13,15,17,24,28,29],copy_and_convert_pixel:[10,28],copy_pixel:[6,7,10,24,28],copyabl:10,copyconstruct:[2,4],copyconstructibleconcept:14,cordelia:18,corner:[7,10,18,28],correct:28,correctli:[4,17],correspond:[1,2,5,8,10,14,19,28],cost:5,could:[6,7,10,14,15,19,24,28],count:7,counter:28,counterpart:24,coupl:24,cours:[15,24],cover:18,cpp:[3,22],creat:[1,3,6,7,8,12,13,14,15,22,24],create_with_margin:7,current:[3,6,14,15,24,28],curvatur:[18,20],custom:[1,10,15],d_channel_t:28,data:[1,5,8,9,10,24,25,28],dave:17,deal:28,dealloc:28,debug:28,decent:24,declar:28,decrement:15,dedic:[11,20],deep:[6,9,17,28],deeper:18,default_color_convert:10,default_color_converter_impl:8,defaultconstruct:4,defaultconstructibleconcept:14,defin:[0,1,2,3,4,6,10,12,13,14,15,16,17,22,24,28],definit:[3,27],degrad:28,degre:28,delai:15,deleg:10,delet:9,demand:24,demonstr:[10,24,28],denot:[14,17,28],depend:[19,23,24],depth:[0,6,7,10,12,14,25,28,29],deref:[10,15],deref_compos:14,deref_t:8,derefer:[8,28],dereferenc:[7,8,10,12,14,15,17],dereference_iterator_adaptor:14,deriv:[10,18,20],derived_image_typ:[12,28],derived_iterator_typ:[12,28],derived_pixel_reference_typ:[12,28],derived_view_typ:[12,28],describ:[0,2,4,11,15,16,20,24],descript:[24,25],design:[0,2,5,22,24,28],desir:28,despit:6,destin:[1,6,7,8,24,28],destroi:6,destructor:[9,28],det:18,detail:[2,6,14,24],detect:[20,28],detector:[20,22],determin:[14,15,18],develop:[10,21],devic:24,devicen_t:3,diagram:15,diff:14,differ:[1,6,13,14,15,17,18,19,24,28],difference_typ:[10,15],difficult:[0,28],dim:[6,9,28],dimens:[6,9,10,15,16,18,24,28],dimension:[7,9,10,15,16,28],direct:[12,14,15,18,19,24,28],directli:[7,13,15,17,24,28,29],directori:27,disadvantag:28,discrimin:18,discuss:0,disk:[6,8,28],dispatch:8,displai:24,distanc:[14,28],distinct:[1,13,18,28],distribut:13,dither:24,divis:14,do_swap:6,document:[0,4,19,20,24,28],doe:[1,7,10,12,17,23,28],doesn:[24,28],doing:[6,8,13],don:[6,8,9,10,12,13,15,28],done:[7,15,19,24,28],doubl:[8,28],down:[6,7,10],download:[10,23],draw:19,drawback:28,drive:24,dst:[1,2,7,8,10,24,28],dst_channel_t:28,dst_it:28,dst_pixel:28,dst_row_byt:28,dst_view:24,dstchannel:1,dstcolorspac:8,dstimag:7,dstp:[8,10],dstpixel:13,dstview:28,due:13,duplic:29,dure:[21,24],dxdx:18,dxdy:18,dydi:18,dynam:[11,12,14,15,22,24],dynamic_at_c:[2,13],dynamic_imag:[6,22,28],dynamic_image_al:[6,28],dynamic_x_step_typ:[6,10,14],dynamic_xy_step_transposed_typ:10,dynamic_xy_step_typ:[6,10],dynamic_y_step_typ:[10,15],each:[0,2,7,8,10,13,15,16,24,28],earli:[10,28],easi:[24,28],easier:[10,28],easili:28,edg:[18,28],effect:[19,28],effici:[0,7,10,14,15,28,29],either:[6,7,8,10,14,24,28],element:[2,3,10,11,13,14,19,28],element_const_reference_typ:[2,13],element_recurs:2,element_reference_typ:[2,13],element_typ:2,els:[8,15],email:24,enabl:24,encod:24,end:[0,7,9,10,15,24,28,29],enough:18,ensur:[10,28],entir:28,enumer:[24,28],epipolar:21,equal:[1,2,3,6,10,13,15,28],equal_pixel:10,equalitycompar:[1,2,4],equival:[2,6,10,14,15],error:[1,6,7,10,17,28],especi:6,essenti:0,establish:25,etc:[0,6,10,13,23,24,28],european:18,evalu:[12,14],even:[6,7,8,24,28,29],ever:7,everi:[5,6,10,14,15,25,28,29],everyth:8,exact:19,exactli:13,exampl:[1,2,3,4,6,8,10,11,12,13,14,15,17,19,24,25,28,29],except:[2,6,8,10,14,15,23,28],exclud:28,execut:[6,28],exercis:28,exist:[5,7,8,24,29],expect:24,expens:28,explan:[10,18,24],explicit:[6,13,28],explicitli:28,extend:[5,11,22,28],extending_gil__io_with_new_format:24,extens:[6,8,10,23,28,29],extern:24,extra:[7,10,13,28,29],extract:28,extrem:18,fact:[24,28],factori:[8,10,28],fail:28,fall:[7,10],fals:[8,12,15,28],familiar:28,far:28,fast:[10,15,28],faster:[1,5,9,15,28],fastest:7,featr:29,featur:[18,20,21,24,29],fetch:28,few:24,file:[6,8,23,24,28],file_nam:6,filenam:24,filesystem:24,fill:[2,7,10,13,15,24,28],fill_pixel:[7,10,24],fill_valu:9,filter:[15,20],find:[15,23],first:[0,1,2,3,6,7,8,10,13,15,21,24],first_argument_typ:10,firstbit:1,fit:13,five:[3,5,12],flat:19,flavour:24,flexibl:[1,6,12,29],flip:[10,14,28],flipped_left_right_view:10,flipped_up_down_view:10,float_on:1,float_zero:1,fly:14,focu:28,focus:28,folder:[19,22,24],follow:[0,1,2,3,5,6,7,9,10,12,13,15,16,18,24,25,27,28,29],for_each:[2,7,10,28],for_each_pixel:[7,10,28,29],for_each_pixel_posit:[10,28],form:[0,9,12,13,18,19,28],format:[13,23,28],format_tag:24,formattag:24,forward:14,forwardtraversalconcept:14,found:24,four:[15,28],fourth:7,frame:21,framework:24,frederik:18,free:[15,23,28],freeli:[7,10],frequent:15,friendli:[15,28],from:[0,1,5,6,7,8,12,13,14,15,18,22,23,24,28,29],fulfil:4,full:[6,13],fulli:[8,24,28],fun:10,function_requir:13,fundament:[1,15,21],fundamental_step:14,further:17,furthermor:[24,28],futur:29,gap:10,gaussian:[18,19],gener:[0,2,4,6,7,9,10,11,14,16,18,19,25],generate_pixel:10,geometri:21,get:[1,6,8,10,12,14,18,19,28],get_color:[2,7,8,13],get_info:24,get_num_bit:27,get_num_it:28,get_pixel_typ:27,get_read_devic:24,get_reader_backend:24,gil:[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,20,22,23,25,27,30],gil_function_requir:[2,7,10,28],github:23,give:[7,15,24],given:[0,2,6,8,9,10,12,13,14,15,17,18,28],glimps:28,global:28,goal:5,goe:28,going:15,good:[19,28],googl:21,gool:18,gradient:[18,19,22],grai:[7,8,18,27],graph:19,grate:17,gray16:24,gray16_image_t:[24,28],gray16_pixel_t:28,gray16_step_view_t:10,gray16c_view_t:28,gray1:[24,28],gray1_image_t:24,gray2:24,gray32s_pixel_t:28,gray32s_view_t:28,gray4:24,gray4_image_t:24,gray7:24,gray8:24,gray8_image_t:[6,24,28],gray8_pixel_t:[7,8,28,29],gray8_view_t:7,gray8c_loc_t:28,gray8c_view_t:28,gray8s_image_t:28,gray8s_pixel_t:28,gray8s_view_t:28,gray_alpha:24,gray_alpha_16:24,gray_alpha_8:24,gray_channel_t:7,gray_color_t:[7,8],gray_cs_t:7,gray_image_t:28,gray_layout_t:28,gray_pixel_t:28,gray_t:[3,7,8,12],gray_to_rgb:7,grayimage_histogram:[7,29],graypixel:7,grayscal:[7,8,10,12,14,15,28],grayview:[7,29],green:[7,10,13,17,29],green_t:[2,3,7,13],grid:28,group:[0,3],guarante:4,guid:[10,22,28],guidelin:24,gv8:7,half:28,half_x_differ:28,halfdiff_cast_channel:28,hand:[0,5,18,22,28,29],handl:28,happen:[6,18,28],hard:[12,24],hardli:28,harrismatrix:18,has:[2,5,6,7,9,10,12,14,15,24,28],hasdynamicxsteptypeconcept:[14,15],hasdynamicysteptypeconcept:15,hassl:28,hastransposedtypeconcept:15,have:[0,1,2,3,5,6,7,8,9,10,12,13,14,15,18,24,27,28,29],hcb:2,header:[23,24,27],heidelberg:18,height:[6,7,9,10,28,29],help:19,helper:12,here:[0,1,2,3,4,6,7,8,10,12,13,14,15,19,24,28],hessianmatrix:18,heterogen:[12,13,28],higher:8,hill:[18,19],his:24,hist:[7,29],histogram:22,homogen:[2,13,14,28],homogeneous_color_bas:[2,14],homogeneouscolorbaseconcept:[2,13,14],homogeneouscolorbasevalueconcept:2,homogeneouspixel:13,homogeneouspixelbasedconcept:[12,13],homogeneouspixelconcept:13,homogeneouspixelvalueconcept:13,hopefulli:[24,27],horizont:[7,12,14,15,19,28],how:[1,3,6,7,8,10,12,13,14,18,24,28],howev:[2,10,28],hpp:[6,8,22,23,24,27,28],hsl:27,hsv:27,html:10,http:[10,23,30],ident:[7,8],ifstream:24,ignor:[13,28],illustr:[6,7,28],imag:[0,5,11,13,14,16,18,19,21,23,25,27,29],image_read_info:24,image_read_set:24,image_t:[6,24],image_typ:[8,12,27,28],image_view:[6,9,10,28],image_write_info:24,imageconcept:[6,7,9,12],imagemagick:24,imagetyp:6,imageviewconcept:[6,7,9,10,12,28],imageviewtyp:6,imagin:19,img:[6,7,9,10,15,24,28,29],img_view:8,immut:[6,9,10,12,14,15,25,28],impact:[10,28],implement:[1,2,6,8,10,13,14,15,17,18,23,24],impos:1,improv:[27,28],in1:28,in2:28,in_buff:24,inaccuraci:24,inc:14,includ:[4,6,23,24,27,28],incompat:[1,6,7,24,28],incomplet:24,incorrect:28,incorrectli:17,increas:10,increment:[14,15,28],independ:[15,24,28],index:[2,10,13,15,24,28,29],indexed_imag:27,indic:[1,12,15,19,25,28],indica:25,ineffici:6,info:24,inform:[1,15,24],inher:14,inherit:13,initi:[7,13,21,28],inlin:[6,8,28],inner:28,input:[10,19,28],insid:[6,7,8,10,15,16,28],instal:[22,24],instanc:[6,8,14,24,28],instanti:[6,10,15,28],instead:[1,2,9,28],instruct:28,instrument:5,int_:2,integ:[1,7,10,15,24,28],integr:[1,3,12,14,25,28],intel:15,intens:[1,18,19],interest:18,interfac:15,interleav:[0,6,7,8,9,10,12,13,14,15,25,28,29],interleaved_ptr:22,interleaved_ref:22,interleaved_view:[10,24,28],intermedi:7,intern:[14,18,29],internet:8,interpret:[3,10],introduc:24,invari:18,invert:8,invert_pixel:17,invok:[2,6,7,8,10,12,14,15,28],involv:28,ios:24,ios_bas:24,is_1d_travers:[10,15],is_bit_align:27,is_homogen:27,is_iterator_adaptor:14,is_mut:[1,8,13,14,28],is_pixel:13,is_planar:[12,13],is_sam:[6,7,13],is_similar:27,ismut:12,isplanar:[9,12],isstep:12,isstepx:12,issu:[17,28,29],isxstep:12,isystep:12,iter:[1,2,5,7,8,9,10,11,13,17,22,25,29],iterator_adaptor_get_bas:14,iterator_adaptor_rebind:14,iterator_from_2d:[10,15],iterator_is_mut:14,iterator_t:24,iterator_trait:[13,17,28],iterator_typ:12,iterator_type_from_pixel:12,iteratoradaptorconcept:14,its:[1,3,6,7,9,12,13,14,15,27,28],itself:[7,13],jiri:18,journal:18,jpeg:[8,28],jpeg_dynamic_io:6,jpeg_lib:24,jpeg_read_imag:[6,7,28],jpeg_tag:24,jpeg_wiki:24,jpeg_write_view:[6,7,28],jpg:[7,24,28],just:[7,8,9,12,13,15,24,27,28],kadir:18,keep:[0,14,28],kei:18,kernel:[7,20],kind:24,know:24,krystian:18,kth_element_const_reference_typ:2,kth_element_reference_typ:2,kth_element_typ:[2,13],kth_semantic_element_const_reference_typ:2,kth_semantic_element_reference_typ:2,kth_semantic_element_typ:[2,13],lab:27,lack:[24,28],laid:7,lambda:[7,29],larg:24,larger:7,largest:7,last:[10,13,24,28],lastli:17,later:[2,15],latest:23,latter:[7,13],layout:[2,5,11,12,13,14,22,25,28],layout_t:2,least:[6,28],leav:28,lectur:22,left:[7,10,14,15,24,28,29],let:[8,18,19,28,29],level:[1,6,24,28],lib:24,libjpeg:[23,24],libpng:[23,24],librari:[0,5,8,10,11,20,23,24,27,29],libraw:24,libtiff:24,lightweight:[7,10,15,28],like:[0,6,7,8,12,13,14,18,19,23,24,28],limit:[5,6],line:28,linear:[1,6],linearli:[1,28],link:[23,24,30],list:[11,20,24],littl:[13,19],live:8,load:[6,28],loc2:15,loc:15,local:24,locat:[5,8,9,10,11,12,13,14,16,22,25],locator_t:28,locator_typ:12,look:[8,18,19,24,28],loop:[10,15,28],lossi:[1,13],lot:[24,28],lower:24,lubomir:30,luc:18,lumin:19,luminos:[7,28,29],luminosity8bit_hist:29,luminosity_hist:29,luminosity_histogram:7,macro:[24,29],made:27,magnitud:28,mai:[0,1,3,4,6,7,8,10,13,14,15,28],main:27,maintain:[27,28],make:[0,6,7,8,10,15,24,28],make_scanline_read:24,make_step_iter:14,mandel:28,mandel_grad:28,mandelbrot:[8,14,15,22,28],mandelbrot_fn:28,mani:[5,6,9,10,24,28],manipul:5,manual:24,map:[1,3,7,13],margin:7,mark:0,mata:18,match:[1,10,17,24,28],matric:[18,19],matrix:[18,19],matter:18,max:1,max_el:2,max_valu:1,maximum:1,mayb:17,mean:[6,7,9,15,19,23,28],meant:24,measur:[6,15,28],mechan:[6,8,15,28],median:19,member:[8,14,17,24],memmov:[7,10],memori:[0,2,3,7,13,14,15,28,29],memory_based_2d_loc:15,memory_based_step_iter:[14,15],memorybasediteratorconcept:[14,15],memunit:[14,15],memunit_adv:14,memunit_advanc:14,memunit_advanced_ref:14,memunit_dist:14,memunit_step:14,mention:24,meta:28,metafunct:[2,4,10,11,13,14,15,16,22,27,28],metaprogram:24,method:[7,8,10,14,15,28],might:[18,19,24,28],mike:18,mikolajczyk:18,mileston:24,min:1,min_el:2,min_valu:1,mind:5,minimum:1,minisblack:24,minor:5,miss:28,mitig:28,mix:7,mode:[24,28],model:[0,4,5,6,7,8,12,17,28],modern:[24,28],modifi:[10,13,14,16,28],modul:[6,8],moment:18,monkei:7,monkey_transform:7,mono:24,moravec:18,more:[1,2,4,6,7,8,9,10,12,13,14,15,24,28],most:[2,4,8,9,10,13,15,16,23,24,28],motiv:1,move:[10,15,18,24,28],mp11:28,mp_list:28,mpl:[2,3,6,12,13,14,24],much:28,multi:24,multipl:[7,10,15,28],multipli:[1,14,28],must:[2,4,10,13,14,15,17,28],mutabl:[1,9,10,12,13,14,15,17,25,28],mutable_forwarditeratorconcept:14,mutablechannelconcept:1,mutablecolorbaseconcept:[2,13],mutablehomogeneouscolorbaseconcept:[2,13],mutablehomogeneouspixelconcept:[7,13],mutableimageviewconcept:[9,10,28],mutableiteratoradaptorconcept:14,mutablepixelconcept:[7,13,17],mutablepixeliteratorconcept:14,mutablepixellocatorconcept:[10,15],mutablerandomaccess2dimageviewconcept:10,mutablerandomaccess2dlocatorconcept:15,mutablerandomaccessiteratorconcept:14,mutablerandomaccessndimageviewconcept:[9,10],mutablerandomaccessndlocatorconcept:15,mutablestepiteratorconcept:[14,15],my_any_image_t:6,my_color_convert:8,my_color_converter_impl:8,my_img_typ:[24,28],my_reference_proxi:17,my_valu:17,my_view:7,my_virt_view_t:28,myimg:6,myit:17,n2081:4,name:[7,13,15,19,22,28,29],namespac:[2,6,17,24,27,28],nativ:[1,28],natur:15,navig:[10,14,15],necessari:[14,15,17,24,28],need:[1,4,7,8,10,12,13,14,15,24,27,28],neg:14,negat:10,neighbor:[15,28],neighborhood:15,neighbour:10,nest:[10,28],never:[6,7,28],new_dim:9,next:[8,10,24,28,29],nice:28,noisi:18,non:[7,10,12,13,15,17,24,25,28],none:[24,28],normal:28,note:[0,1,2,6,7,9,10,13,18,24,28],noth:13,notic:[2,7,18,28],notion:28,now:[18,24,28],nth_channel_deref_fn:14,nth_channel_view:[7,10,28,29],nth_channel_view_typ:10,nth_channel_x_gradi:28,num_channel:[6,10,12,13,28],num_dimens:[10,15,16],number:[2,6,7,10,13,14,15,18,28],numbit:1,numer:[10,18,22],numeric_limit:1,obj:6,object:[6,8,10,12,14,15,17,24,25,28,29],obtain:[15,28],occupi:13,off:28,offer:15,offset:[1,14,15,28],ofstream:24,often:[3,6,13,28],old:28,onc:[0,5,10,28],one:[2,4,6,7,8,10,12,13,14,15,19,24,28],ones:[6,8,13,18],onli:[1,2,6,7,8,10,13,14,15,17,18,23,24,27,28,29],onlin:24,open:6,oper:[1,2,4,6,8,9,10,13,14,15,16,17,22,24,25,28,29],oppos:[7,10,12,25,28],optim:[5,7,10,15,28],option:[0,8,18,22,24,28],order:[0,2,3,6,7,10,12,13,15,18,23,25,28,29],organ:[12,13,15,25],origin:[6,10,28,30],other:[2,4,8,13,14,15,18,19,24,25,28,29],otherwis:[8,13],our:[6,7,8,28],out:[24,28],out_buff:24,outdoor:18,output:28,outsid:28,over:[1,9,10,13,14,18,25,28],overhead:[6,28],overlai:18,overload:[6,10,17,28],overrid:[7,8,15],overview:[20,22],own:[4,8,9,10,15,22,24,28],ownership:[9,28],pack:[9,13,14,28],packed_channel_refer:1,packed_channel_valu:1,packed_dynamic_channel_refer:1,packed_image1_typ:12,packed_image2_typ:12,packed_image3_typ:12,packed_image4_typ:12,packed_image5_typ:12,packed_image_typ:12,packed_pixel:[2,13,14,22],packed_pixel_typ:13,pad:[0,7,9,15],page:24,pair:[2,13,28],pairwis:[1,10,13],palett:24,paper:[4,18],paramet:[0,1,5,6,7,8,9,10,14,15,17,24,28],parent:17,part:[24,29],partial:24,particular:[6,18,28],pass:[6,8,10,28],past:10,patch:18,path:[6,24],pattern:[1,7,12,28],peopl:27,per:[6,10,14,15,28],percent:24,perform:[6,8,10,14,15,22,28],permut:2,physic:[1,2,3,7,13],pick:24,pipe:28,pix_buff:13,pix_it:13,pixel1:13,pixel2:13,pixel:[0,1,2,3,4,5,6,8,9,11,16,17,19,22,25,29],pixel_2d_locator_bas:15,pixel_bit_s:27,pixel_refer:12,pixel_reference_typ:12,pixel_value_typ:12,pixelbasedconcept:[12,13,14,28],pixelconcept:[4,7,8,10,12,13,14,15],pixelconvertibleconcept:13,pixeldata:14,pixeldereferenceadaptorconcept:[8,10,14,15,28],pixeliteratorconcept:[10,12,14,15],pixellocatorconcept:[10,15],pixelrefer:12,pixelscompatibleconcept:[10,13],pixelvalueconcept:[8,9,10,13,14,15],place:28,plain:14,planar:[0,2,6,7,9,10,12,13,14,15,17,24,25,28,29],planar_pixel_iter:[14,15],planar_pixel_refer:[13,17],planar_rgb_view:[10,28],plane:[0,7,10,19,28],platform:[15,22],pleas:[18,24],plot:19,plu:15,png_lib:24,png_test_fil:24,png_wiki:24,pnm_wiki:24,point2dconcept:[15,16],point:[0,1,6,10,11,12,13,15,18,22,24,25,28],point_t:[6,9,10,15,24,28],point_typ:10,pointer:[1,7,8,10,13,14,15,24,25,28],pointndconcept:[10,15,16],polici:[0,10,29],popular:23,posit:[14,15,28],position_iter:14,possibl:[6,10,13,24,28],potenti:[0,24],pow:28,power:[6,7,18,28],practic:[6,28],pre:28,precis:1,prefix:2,presenc:0,present:[28,29,30],pretend:14,previou:[0,6],previous:[10,28],price:12,privat:[8,10,15,24,28],probabl:24,problem:[12,17,28],process:[0,10,21,22,28],processor:28,produc:19,product:[28,29],profil:8,program:[4,24,28,29],project:[0,21,23],propag:[10,28],proper:28,properli:[1,2,7,8,24,28],properti:[12,13,22,28],propos:4,provid:[0,1,2,3,5,6,8,9,10,12,13,14,15,16,17,19,24,27,28,29],proxi:[1,2,13],ptr:7,ptrdiff_t:[6,10,14,15,28],pull:14,purpos:13,put:[19,28],quadrant:29,qualifi:17,qualiti:[8,24],queri:28,r565:13,rais:28,random:[3,6,14,15,28],randomaccess2dimageconcept:9,randomaccess2dimageviewconcept:10,randomaccess2dlocatorconcept:15,randomaccessndimageconcept:9,randomaccessndimageviewconcept:10,randomaccessndlocatorconcept:[10,15],randomaccesstraversalconcept:[10,14,15],randomaccesstraversaliteratorconcept:14,rang:[1,2,9,10,28],range_c:3,rare:[9,28],rather:24,raw:[5,15,28],raw_wiki:24,rbegin:10,rbg323:24,rdbuf:24,read:[0,8,10,12,13,14,15,28],read_and_convert_imag:24,read_and_convert_view:24,read_imag:24,read_image_info:24,read_view:24,read_xxx:24,reader:[24,28],reader_bas:24,reader_t:24,real:[17,28],realiz:28,rebind:14,recommend:[0,24],recreat:[6,7,9],rectangular:[10,28],recurs:[2,14,28],red:[0,1,2,7,13,14,17],red_in_cmyk16:13,red_in_rgb8:13,red_t:[2,3,13],redefin:8,ref2:7,ref:[7,13],refer:[1,2,7,8,10,12,13,14,15,18,22,24,25,28],refin:16,regardless:28,region:[20,22,28],regist:28,regular:[1,2,4,9,10,13,15,16],rel:[15,28],relat:[4,12,28],releas:21,relev:24,remain:8,rememb:[15,17],remov:[24,28,29],remove_refer:14,rend:10,repeat:15,replac:12,repres:[0,15,17,24,28],represent:[0,5,22,28],request:24,requir:[1,2,4,6,8,9,10,13,14,15,22,23,24,28],resampl:10,rescal:22,resembl:[6,10],resid:28,resiz:[10,22],resolut:[5,6],respect:[7,13,28],respons:18,rest:[12,28],restrict:24,result:[0,2,5,6,7,8,10,12,13,14,15,18,24,28],result_typ:[4,6,8,10,14,28],reus:28,reverse_iter:10,review:[24,27],rewrit:28,rewritten:29,rgb16:24,rgb16_image_t:[10,28],rgb16c_planar_view_t:28,rgb222:28,rgb32f_planar_step_ptr_t:[12,25],rgb32f_planar_view_t:7,rgb32fc_view_t:28,rgb32s_pixel_t:28,rgb32s_view_t:28,rgb565:13,rgb565_channel0_t:13,rgb565_channel1_t:13,rgb565_channel2_t:13,rgb565_pixel_t:13,rgb64_image_t:8,rgb64_pixel:8,rgb64_pixel_ptr_t:8,rgb64_pixel_t:8,rgb8:[13,24],rgb8_image_t:[6,24,28],rgb8_pixel_t:[7,13,28],rgb8_planar_ptr_t:14,rgb8_planar_ref_t:[7,13],rgb8_planar_view_t:12,rgb8_ptr_t:10,rgb8_step_view_t:6,rgb8_view_t:[6,7],rgb8c_planar_ptr_t:[7,14],rgb8c_planar_ref_t:[7,13],rgb8c_ptr_t:10,rgb8c_view_t:[6,28],rgb:[0,1,2,7,8,10,12,13,14,24,25,28,29],rgb_channel_t:7,rgb_cs_t:7,rgb_full:13,rgb_layout_t:[7,8,13],rgb_planar_pixel_iter:17,rgb_t:[3,7,13,14],rgba16:24,rgba8:24,rgba8_image_t:24,rgba:[0,3,12,25,27],rgba_image_t:24,rgba_layout_t:[3,7],rgba_t:3,rgbpixel:7,rgbtograi:29,right:[7,10,14,15,28],rise:15,rotat:[6,10,28],rotated180_view:[6,7,10],rotated180_view_fn:6,rotated90ccw_view:[10,28],rotated90cw_view:[10,28],row:[0,7,9,10,13,14,15,24,28,29],row_begin:[10,28],row_end:10,rowsiz:10,rpv32:7,rule:23,run:[0,1,5,6,7,10,21,22],runtim:6,runtime_imag:[24,28],rview:10,said:6,sake:10,same:[1,2,3,6,7,8,10,13,15,16,18,19,24,28],sametyp:[1,2,4,10,13,14,16],sampl:[15,22,24,28,29],satisfi:[2,4,9,10,15,28],sav:6,save:[6,24,28],save_180rot:6,scale:28,scanlin:24,scanline_read:24,scanline_read_iter:24,scenario:[2,28],schaffalitzki:18,scharr:19,scharrx:19,schmid:18,scoped_channel_valu:1,sean:17,second:[0,1,7,13,15,17,18,24,28,29],second_argument_typ:10,section:[0,2,10,11,20,24,27],see:[2,4,8,10,14,15,24,28],seek:24,select:6,semant:[2,3,13,28],semantic_at_c:[2,7,13],send:24,separ:[0,8,10,18,28],sequenc:[1,3],serv:24,set:[0,1,3,4,6,7,8,9,10,13,14,15,24,28],set_step:14,sever:[5,14,24,28],shallow:[6,7,10,14,17,28],shape:19,share:[6,13,24],sharper:19,she:24,shift:1,shortli:29,should:[6,15,18,23,24,28],show:[7,24,28],shown:[7,28],side:28,sigma:19,sign:[12,25,28],signific:10,similar:[1,10,14,15,22,24,28],similarli:[9,14],simpl:[12,15,19,24,28,29],simpler:[18,24,29],simplest:[19,28],simpli:[7,8,15,18,19,28],simplic:28,simplifi:[7,18,28],simultan:28,sinc:[6,7,13,14,24,27,28,29],singl:[6,10,14,19,24,28],size1:12,size2:12,size3:12,size4:12,size5:12,size:[2,3,6,7,10,13,14,15,24,28],size_t:[2,6,9,10,13,15,16],size_typ:[6,10],sizeof:13,skeleton:24,skip:[10,14,28,29],slightli:[8,28],slow:28,slower:[15,28],small:[18,24,27],smaller:7,sobel:19,softwar:29,solut:17,some:[0,4,6,7,8,10,12,13,14,15,17,24,28],sometim:[1,10,13,14,15,17,24,28],somewher:8,soon:24,sort:19,sourc:[1,6,7,8,10,24,25,28,29,30],space:[0,2,5,6,7,10,11,13,14,22,24,27,28,29],special:[8,13,25,28],specif:[0,5,22,24,28],specifi:[0,1,3,5,6,8,9,12,14,22,24],speed:[0,5,6,10,28],spirit:15,springer:18,sr8wjg0pcee:30,src1:10,src1_it:28,src2:10,src2_it:28,src:[1,2,6,7,8,10,24,28],src_b:28,src_g:28,src_it:28,src_loc:28,src_pix_ref:8,src_pixel:28,src_r:28,src_row_byt:28,srcchannel:1,srccolorspac:8,srcconstrefp:8,srcp:8,srcpixel:13,srcview:[7,8,10,28],srowbyt:29,stabl:18,stage:10,standalon:27,standard:[3,4,10,12,14,15],start:[10,13,15,24,28],state:10,statement:[6,28],static_:2,static_assert:[6,7,12,13],static_copi:2,static_equ:2,static_fil:[2,7,28],static_for_each:[2,28],static_gener:[2,28],static_max:2,static_min:2,static_transform:[2,14,28],std:[1,2,6,7,9,10,12,13,14,15,17,24,28,29],step1:7,step2:7,step3:7,step4:7,step5:7,step:[6,10,12,15,20,25,28],step_iterator_t:12,stepanov:17,stephen:18,stepiter:15,stepiteratorconcept:[14,15],still:28,stl:[2,5,6,9,15,17],stlab:10,store:[6,7,15,24,28],straightforward:[10,24],stream:24,strength:19,stretch:19,string:[6,24],stringstream:24,strip:24,strongli:24,struct:[1,2,3,6,8,10,12,13,14,15,16,17,24,28],structur:[0,6,10,11,18,20,22,28],studio:28,sub:[1,17,24,27],subclass:[6,14,15],subimag:28,subimage_view:[7,10,24,28,29],subject:24,suboptim:28,subsampl:[10,14,28],subsampled_view:[7,10,28,29],substitut:4,succinct:10,suffici:[15,23],suffix:25,suggest:[17,27],suit:24,suitabl:28,sum:18,summer:21,suppli:[8,10,14,15,24],support:[0,1,6,7,8,10,12,14,22,28,29],supported_image_format:24,suppos:[6,7,8,28],sure:24,swap:[4,15,17],swappabl:[1,2,4],symmetr:13,synopsi:[10,15],syntact:4,syntax:4,synthet:[8,22,28],system:[24,28],tabl:[11,20,24],tag:[24,25],tag_t:24,take:[2,6,7,8,9,10,14,15,17,24,28,29],taken:28,targa_wiki:24,target:[5,24,28],task:28,technic:[11,22],techniqu:[6,24],tell:23,templat:[1,2,3,4,6,7,8,9,10,12,13,14,15,16,17,24,28,29],temporari:[17,28],term:[16,18],test:[22,25],test_imag:24,text:24,than:[2,6,7,13,14,15,24,28],thank:[24,27],thei:[1,2,3,5,6,7,8,10,12,13,14,15,18,19,28],them:[1,4,6,9,10,12,13,24,28],therefor:1,thi:[0,1,2,4,6,7,8,10,12,13,14,15,17,18,19,24,25,27,28,29,30],thing:[7,19,24],think:28,third:24,thorough:24,those:[13,19],though:[6,7,19,28],three:[1,13,14,18,19,28],threshold:18,through:[7,15,24,28],thrown:28,thu:[1,2,3,8,15],tif:24,tiff_base_tag:24,tiff_extension_tag:24,tiff_graphicsmagick_test_fil:24,tiff_lib:24,tiff_lib_tiff_test_fil:24,tiff_t:24,tiff_tag:24,tiff_wiki:24,tile:24,time:[0,1,2,5,6,7,8,10,14,22],timor:18,tinn:18,tmp:[14,17],todo:26,togeth:[0,3,13,28],toll:[6,28],too:27,toolbox:[22,24],top:[0,7,10,12,15,24,28,29],top_left:10,total:[10,15],trace:18,track:[10,14,28],transform:[1,2,6,8,10,18,22],transform_pixel:[10,28],transform_pixel_posit:[10,28],transpos:[10,15,28],transposed_typ:[10,15],transposed_view:10,travers:[9,10,14,15,24,25,28],treat:[6,28],tricki:17,trickier:28,trigger:[6,28],trivial:25,troubl:24,true_:[12,14],turn:6,tutori:[8,10,15,22],tuytelaar:18,tweak:19,twice:28,two:[0,1,2,3,6,7,9,10,13,14,15,16,18,19,21,24,28],type:[0,1,2,3,4,5,6,7,9,10,13,14,15,16,17,22,24,27,28,29],type_from_x_iter:12,typedef:[1,6,7,8,10,12,13,14,17,24,28],typenam:[1,2,3,4,6,7,8,9,10,12,13,14,15,16,17,24,28,29],typic:[1,6,8,10],ud_fud:10,uint16_t:[1,13],uint8_t:[1,18,29],unari:[14,28],unary_compos:14,unary_funct:14,unaryfunctionconcept:[10,14],unchang:28,unclear:15,under:[18,24],underli:[6,10,14,24],understand:[1,18,19,24],unfamiliar:28,unfortun:28,uniformli:6,uninitialized_copi:10,uninitialized_copy_pixel:10,uninitialized_fil:10,uninitialized_fill_pixel:10,uniqu:3,unit:[14,15,24],unless:19,unlik:[9,13],unnam:3,unnecessari:[7,13,28],unpack:13,unrel:29,unrol:28,unset:10,unsign:[6,7,9,10,12,13,14,25,28],unspecifi:4,until:18,unus:[13,28],unusu:28,upon:[6,8,10,12,14,15,17],upper:29,upsid:[6,10],usag:[19,24],use:[1,2,4,7,8,10,12,13,15,17,19,23,24,28],use_default:12,used:[2,3,4,5,6,7,9,13,14,15,16,18,19,24,25,28],useful:[8,9,14,15,28],user:[0,4,8,10,15,24,27,28],uses:[2,6,10,12,14,15,16,24,28],using:[1,2,3,6,7,8,9,10,12,13,15,22,24,28,29],using_io:24,usual:[14,18,19,24],val:10,valid:[1,10,28],valu:[0,1,2,3,6,7,8,9,10,12,13,14,15,16,17,18,19,24,25,28],value_typ:[1,8,9,10,13,14,15,16,24,28],valueless:6,van:18,vari:[0,3,28],variabl:[0,28,29],variant2:6,variant:[6,24,28],variat:[0,24],varieti:[22,28],variou:24,vector3_c:13,vector4:3,vector4_c:3,vector:[24,28],veri:[9,12,18,28,29],version:[10,14,15,23,24,29],vertic:[12,14,15,19,28],via:[6,10],video:[0,22,28],view1:10,view2:10,view:[5,9,11,13,14,15,22,24,25,29],view_is_mut:12,view_t:[6,7,9,10,12,24],view_typ:12,view_type_from_pixel:12,viewer:24,viewscompatibleconcept:[7,10],viewtyp:6,virtual:[5,8,12,14,15,24],virtual_2d_loc:[15,28],vision:[0,18],visit:[10,15],visual:28,vol:18,wai:[2,13,17,19,24,25,28],walk:[24,28],want:[7,8,14,15,24,28],warn:28,watch:30,web:4,websit:24,weight:[18,20],well:[2,13,24,28],were:[21,28],what:[6,19,20,24,28],when:[2,7,8,9,10,14,15,17,18,19,24,28],where:[1,2,7,9,10,12,13,14,15,16,23,24,25,28],wherea:[0,2,6,19,24,28],whether:[1,10,12,14,15,28],which:[0,1,2,3,6,7,8,9,10,12,14,15,16,19,23,24,25,27,28],who:27,whose:[0,2,10,12,13,14,22,28],why:28,width:[6,7,9,10,15,28,29],window:[18,24],within:10,without:18,word:[0,9,10,14,19,28],work:[0,5,6,7,8,10,13,17,18,22,28,29],worth:[7,24,28],would:[0,6,14,19,24,28],wrap:[6,10,14],wrapper:[14,15],write:[0,5,6,7,10,17,22,28],write_view:24,writer:24,written:[15,19,24,28,29],wstring:24,www:30,x_at:[10,15],x_coord_t:[6,9,10,15],x_diff:15,x_gradient:[22,28],x_gradient_obj:28,x_gradient_rgb_luminos:28,x_gradient_unguard:28,x_iter:[9,10,13,15,24,28],x_luminosity_gradi:28,x_min:28,xbm:24,xgradientgray16_gray32:28,xgradientplanarrgb8_rgb32:28,xgradientrgb8_bgr16:28,xiter:[12,15],xpm:24,xxx:24,xxx_all:24,xxx_and_convert_xxx:24,xxx_read:24,xxx_tag:24,xxx_write:24,xy_at:[10,15,28],xy_loc:[10,28],xy_locator_t:12,xyz:27,y_at:[10,15],y_coord_t:[6,9,10,15],y_distance_to:15,y_gradient:28,y_iter:[10,15,28],y_min:28,ycbcr:24,ycck:24,yellow:18,yet:[0,24,28],you:[7,8,12,17,24,28],your:[8,17,22,23,24,28],yourself:24,youtub:30,zero:[13,18,28],zisserman:18,zlib:24},titles:["Basics","Channel","Color Base","Color Space and Layout","Concepts","Conclusions","Dynamic images and image views","Examples","Extending","Image","Image View","Design Guide","Metafunctions","Pixel","Pixel Iterator","Pixel Locator","Point","Technicalities","Affine region detectors","Basics","Image Processing","Overview","Boost Generic Image Library","Installation","IO extensions","Naming Conventions","Numeric extension","ToolBox extension","Tutorial: Image Gradient","Tutorial: Histogram","Tutorial: Video Lecture"],titleterms:{"new":[8,24],And:24,Using:[7,24,28],acknowledg:27,adaptor:14,affin:18,algorithm:[1,2,10,13,18,28],align:12,avail:18,base:[2,12],basic:[0,19],being:18,bit:12,bmp:24,boost:22,buffer:24,canva:7,channel:[1,8],code:28,color:[2,3,8,28],compat:5,compil:24,compon:12,concept:4,conclus:[5,28],concret:25,convent:25,convers:[8,28],convolut:19,core:22,creat:[10,17,28],curvatur:19,defin:8,derefer:14,deriv:[12,19],design:11,detect:18,detector:18,document:22,dynam:6,equival:28,exampl:[7,22],exist:12,extend:[8,24],extens:[5,22,24,26,27],filter:19,first:28,flexibl:5,folder:27,format:24,from:10,fundament:14,gener:[5,22,24,28],gil:[24,28,29],glue:28,gradient:28,guid:11,harri:18,hessian:18,histogram:[7,29],homogen:12,imag:[6,7,8,9,10,12,15,20,22,24,28],implement:[28,29],instal:23,interfac:[24,28],iter:[12,14,15,28],jpeg:24,kernel:19,layout:3,lectur:30,level:7,librari:22,locat:[15,28],manipul:12,memori:[12,24],metafunct:12,model:[1,2,3,9,10,13,14,15,16],name:25,numer:26,oper:7,origin:29,other:10,over:15,overload:8,overview:[1,2,3,8,9,10,12,13,14,15,16,21,24,26,27],pack:12,perform:5,pixel:[7,10,12,13,14,15,28],platform:24,png:24,pnm:24,point:16,process:20,proxi:17,quickstart:22,raw:[10,24],read:24,refer:[17,27],region:18,resiz:7,run:[24,28],space:[3,8],specifi:28,step:[14,18],stl:[10,28],structur:27,style:10,support:24,symbol:24,targa:24,technic:17,test:24,tiff:24,time:28,toolbox:27,trait:12,transform:28,tutori:[24,28,29,30],type:[8,12,25],version:28,video:30,view:[6,7,8,10,12,28],virtual:28,weight:19,what:18,write:24}})
\ No newline at end of file
+Search.setIndex({docnames:["design/basics","design/channel","design/color_base","design/color_space","design/concepts","design/conclusions","design/dynamic_image","design/examples","design/extending","design/image","design/image_view","design/index","design/metafunctions","design/pixel","design/pixel_iterator","design/pixel_locator","design/point","design/technicalities","image_processing/affine-region-detectors","image_processing/basics","image_processing/index","image_processing/overview","index","installation","io","naming","numeric","toolbox","tutorial/gradient","tutorial/histogram","tutorial/video"],envversion:{"sphinx.domains.c":2,"sphinx.domains.changeset":1,"sphinx.domains.citation":1,"sphinx.domains.cpp":3,"sphinx.domains.index":1,"sphinx.domains.javascript":2,"sphinx.domains.math":2,"sphinx.domains.python":2,"sphinx.domains.rst":2,"sphinx.domains.std":1,sphinx:56},filenames:["design/basics.rst","design/channel.rst","design/color_base.rst","design/color_space.rst","design/concepts.rst","design/conclusions.rst","design/dynamic_image.rst","design/examples.rst","design/extending.rst","design/image.rst","design/image_view.rst","design/index.rst","design/metafunctions.rst","design/pixel.rst","design/pixel_iterator.rst","design/pixel_locator.rst","design/point.rst","design/technicalities.rst","image_processing/affine-region-detectors.rst","image_processing/basics.rst","image_processing/index.rst","image_processing/overview.rst","index.rst","installation.rst","io.rst","naming.rst","numeric.rst","toolbox.rst","tutorial/gradient.rst","tutorial/histogram.rst","tutorial/video.rst"],objects:{},objnames:{},objtypes:{},terms:{"01100000":13,"0rrgggbb":13,"0x06":13,"0x0c":13,"0x11":13,"0x30":13,"0x60":13,"0x83":13,"0xc1":13,"100":[6,7,10,18,28],"1000":18,"10000":18,"100000000":18,"100x100":7,"127":24,"128":18,"142":18,"150":7,"1988":18,"200":[6,7,28],"2002":18,"2005":18,"200x200":28,"2019":21,"255":[7,13,28],"256":7,"257":1,"300":7,"480":24,"4x3":0,"50x50":10,"5244":18,"565":[1,28],"640":24,"65535":[1,13],"abstract":[0,5,10,22,28],"boolean":[12,28],"byte":[1,9,10,13,14,15,17,22,28],"case":[2,5,7,8,10,12,13,15,18,24,28],"char":[7,9,10,12,13,14,24,28],"class":[1,2,4,6,8,9,10,12,13,14,15,17,24,28],"const":[1,2,6,7,8,9,10,12,13,14,15,16,17,24,25,28,29],"default":[1,3,6,7,8,9,10,12,14,17,25,28],"final":[2,7,8,28],"float":[1,7,12,24,25,28],"function":[2,6,8,10,12,14,15,17,18,22,24,28,29],"import":[6,9,17,24],"int":[1,2,3,7,10,13,15,24,28,29],"long":[4,7,8,10,12,28],"new":[5,28,29],"public":[6,8,10,14,15,24],"return":[1,2,4,6,7,8,10,12,13,14,15,17,24,28],"short":[12,24,28,29],"static":[1,2,6,7,8,10,13,14,15,28],"switch":[6,28],"throw":6,"true":[1,2,12,13,14,15,28],"try":[7,24,28],"var":[7,29],"void":[2,4,6,7,8,9,10,13,14,17,24,28,29],"while":[0,1,3,13,15,28],But:24,For:[1,2,3,4,6,7,8,10,12,13,14,15,18,24,25,28,29],Its:[1,2,13,14,28],Not:7,One:[15,17,18,24,28],Such:[1,6,15,28],That:[6,28],The:[0,1,2,3,4,5,6,7,8,9,10,11,13,14,15,17,18,19,20,21,22,23,24,25,27,28,29],Their:[6,15,28],Then:[15,28],There:[0,2,6,12,19,24,28],These:[2,12,13,28],Use:[17,24],Using:[10,12,15,22,29],_bmp_test_fil:24,_concept_:28,_dimens:10,_dst:28,_height:24,_imag:[12,25],_img_siz:28,_info:24,_io_dev:24,_is_:12,_loc:[12,25],_pixel:[10,12,25],_planar:[12,25],_png_test_fil:24,_ptr:[12,25],_ref:[12,25],_scanline_length:24,_step:[12,25],_tiff_graphicsmagick_test_fil:24,_tiff_lib_tiff_test_fil:24,_variants_:28,_view:[12,25],_width:[15,24],abbrevi:28,abgr_layout_t:3,abil:24,abl:[14,24],about:[4,8,15,19,28,30],abov:[0,2,7,10,13,14,15,17,18,19,24,28,29],abraham:17,access:[1,2,3,6,7,8,13,15,24,28],accessor:[2,16],accordingli:8,account:7,achiev:19,acknowledg:22,actual:[8,29],adapt:1,adaptor:[8,10,15],add:[6,8,15,24],add_deref:[8,10,15],add_fs_path_support:24,add_ref_t:8,added:27,adding:[7,24],addit:[1,2,4,6,9,10,14,15,28],addition:28,address:[0,12,13],adjac:[10,14,28],adob:10,advanc:[10,14,15,24,28],advantag:[28,29],advis:24,affin:[20,22],after:[2,28],again:[15,18],against:[17,23],alex:17,algorithm:[0,4,5,6,7,8,9,14,15,17,20,21,22],align:[0,6,9,10,13,14,22,28,29],all:[0,1,2,3,4,6,7,8,10,13,14,15,17,18,24,27,28],alloc:[7,9,10,12,24,28,29],allocator_typ:9,allow:[0,1,2,5,6,8,9,10,12,13,14,15,17,22,24,28],alon:19,along:[10,12,14,15,16,28],alpha:[0,27],alpha_t:3,alreadi:[12,13,24,28],also:[0,1,2,3,7,10,12,13,14,15,16,24,28,29],altern:28,alvei:18,alwai:[13,17,25,28],amount:[14,15],analog:13,analysi:[12,20],andrew:18,ani:[0,2,5,6,7,8,10,12,14,15,18,19,23,28,29],anoth:[1,2,5,6,8,10,13,14,19,24,28],another_iter:14,any_imag:[6,24,28],any_image_view:[6,28],any_pixel:[6,28],any_pixel_iter:[6,28],anyth:[8,14,24],api:22,append:12,appendix:28,appli:[0,1,14,19,22,24,28],applic:[24,28],apply_oper:[6,28],appropri:[1,6,24],approxim:[13,14,28],arbitrari:[8,14,28],area:[7,10,24],aren:24,argb_layout_t:3,argument:[6,14,28],argument_typ:[8,10,28],aris:17,arithmet:[1,19],around:[7,14,15,24],arrai:[0,14,15,19],ascii:24,assembl:28,assert:[1,7,13,28],assert_sam:6,assign:[1,2,4,6,9,13,17,28],assignableconcept:14,associ:[1,2,3,6,12,28],assum:[18,28],at_c:[2,13],atom:28,author:24,auto:[4,24],avaialbl:4,avail:[6,10,15,20,24,28],averag:15,avoid:28,awai:[10,14],axi:[10,15,16,19,28],axis:19,axis_iter:[10,15],axis_valu:16,b16:7,back:[6,10,28],backend:24,backend_t:24,backward:25,bad_cast:6,base:[1,6,10,11,13,14,15,17,22,24,28,29],basic:[4,11,12,18,20,22,24],becam:24,becaus:[1,6,9,10,12,13,15,18,28],been:[5,24,28,29],befor:24,begin:[7,10,24,28,29],behav:6,being:[12,20,24],belong:27,below:[11,14,15,18,20,24,28],berlin:18,besid:[3,24],beta:10,better:28,between:[1,6,8,10,13,14,28],bgr16_view_t:7,bgr16s_pixel_t:28,bgr16s_view_t:28,bgr232:13,bgr232_pixel_t:13,bgr232_ptr_t:13,bgr232_ref_t:13,bgr556:13,bgr556_pixel_t:13,bgr8:13,bgr8_image_t:[12,25],bgr8_pixel_t:[7,13],bgr8_view_t:6,bgr:[0,2,7,12,13,25,28,29],bgr_layout_t:[3,13],bgra_layout_t:3,big:[18,24],biggest:28,bilinear:22,bin:7,binari:[24,28],binaryfunctionconcept:10,bit:[0,1,2,7,8,9,10,13,14,15,24,25,28,29],bit_align:13,bit_aligned_image1_typ:12,bit_aligned_image2_typ:12,bit_aligned_image3_typ:12,bit_aligned_image4_typ:12,bit_aligned_image5_typ:12,bit_aligned_image_typ:12,bit_aligned_pixel_iter:[13,14],bit_aligned_pixel_refer:13,bitdepth:[12,25],bitfield:12,bitmask:22,bits16:1,bits32f:1,bits8:[7,10,13,14,28],bitwis:10,block:[3,10,28],blue:[2,7,13,17],blue_t:[2,3,7,13],blur:[18,22],bmp_filenam:24,bmp_test_fil:24,bmp_wiki:24,bodi:28,bool:[1,2,4,6,8,9,10,12,13,14,15,28],boost:[3,6,7,10,12,14,21,23,24,27,28,29],boost_check_equ:24,boost_concept:14,boost_gil_extension_io_jpeg_c_lib_compiled_as_cplusplu:24,boost_gil_extension_io_png_c_lib_compiled_as_cplusplu:24,boost_gil_extension_io_tiff_c_lib_compiled_as_cplusplu:24,boost_gil_extension_io_zlib_c_lib_compiled_as_cplusplu:24,boost_gil_io_add_fs_path_support:24,boost_gil_io_enable_gray_alpha:24,boost_gil_io_png_1_4_or_low:24,boost_gil_io_png_dithering_support:24,boost_gil_io_png_fixed_point_support:24,boost_gil_io_png_floating_point_support:24,boost_gil_io_test_allow_reading_imag:24,boost_gil_io_test_allow_writing_imag:24,boost_gil_io_use_bmp_test_suite_imag:24,boost_gil_io_use_png_test_suite_imag:24,boost_gil_io_use_pnm_test_suite_imag:24,boost_gil_io_use_tiff_graphicsmagick_test_suite_imag:24,boost_gil_io_use_tiff_libtiff_test_suite_imag:24,boost_gil_use_concept_check:[10,28],boost_mpl_assert:13,boostorg:23,border:7,both:[0,6,7,13,15,16,18,24,28,29],bottom:[0,10,15,28],bound:[6,13],boundari:28,bourdev:30,buffer:[7,13,28],build:[0,24],built:[1,7,12,13,14,23,28],byte_to_memunit:14,c_str:24,cach:[15,28],cache_loc:[15,28],cached_location_t:[15,28],calcul:29,call:[6,7,8,10,13,17,18,24,28,29],can:[2,4,5,6,7,8,9,10,12,13,14,15,16,17,18,19,22,23,24,28,29],cannot:[7,10,19,28],canon:[13,28],capabl:24,captur:3,care:8,carriag:[15,28],cast:28,caus:[18,28],caution:6,cav:6,cb1:2,cb2:2,cb3:2,cc_t:24,ccv:10,ccv_imag:28,center:[7,19],centerimg:7,central:28,certain:19,challeng:[0,28],chan16:1,chang:[6,8,10,12,14,18,24,28,29],channel16_0_5_reference_t:1,channel16_11_5_reference_t:1,channel16_5_6_reference_t:1,channel1:1,channel2:1,channel3:1,channel:[0,2,3,5,6,7,10,11,12,13,14,17,19,22,24,25,28,29],channel_6bit:1,channel_convert:[1,7,8,13,28],channel_convert_to_unsign:28,channel_invert:[1,8],channel_mapping_t:3,channel_mapping_typ:[12,13,28],channel_multipli:1,channel_t:28,channel_trait:[1,8],channel_typ:[7,12,13,27,28],channel_type_to_index:27,channelbitsizevector:12,channelconcept:[1,13],channelconvertibleconcept:1,channelmap:3,channelmappingconcept:[3,13],channelptr:14,channelrefer:13,channelrefvec:14,channelscompatibleconcept:[1,13],channelvalu:[12,13,14],channelvalueconcept:[1,12],check:[6,7,10,15,28],choic:[15,18],choos:15,chose:7,christoph:18,chunki:28,claim:24,classtyp:[12,25],clear:[19,24],client:23,clockwis:28,close:24,closer:28,cmyk16_pixel_t:[12,13,25],cmyk16_planar_image_t:6,cmyk16_planar_step_view_t:6,cmyk16_planar_view_t:6,cmyk16c_planar_ref_t:25,cmyk16c_planar_view_t:6,cmyk16sc_planar_ref_t:12,cmyk8_image_t:24,cmyk:[0,12,25],cmyk_t:3,cmyka:27,code:[0,3,5,6,7,8,10,15,21,22,24,25,29],col:29,col_begin:10,col_end:10,collect:[6,27],color:[0,1,5,6,7,10,11,12,13,14,15,22,24,25,27,29],color_bas:2,color_const_reference_t:2,color_convert:[8,13,27],color_convert_deref_fn:[8,14],color_convert_view:8,color_converted_view:[7,8,10,28,29],color_converted_view_typ:[8,10],color_converter_typ:24,color_reference_t:2,color_spac:27,color_space_t:[2,3],color_space_typ:[7,8,12,13,28],colorbas:2,colorbaseconcept:[2,13],colorbasescompatibleconcept:[2,13],colorbasevalueconcept:2,colorconvert:10,colorspac:[3,12,13,14,25],colorspace1:3,colorspace2:3,colorspaceconcept:[3,13],colorspacescompatibleconcept:[2,3,28],column:[14,15,28,29],com:[10,23,30],combin:[6,14,15,18,28],come:[12,24],commerci:29,common:[0,2,4,6,24],commonli:13,commun:27,compact:1,compactli:[7,28],compar:[0,1,2,5,6,7,28],comparison:[1,6,15,18],compat:[1,2,3,6,7,10,13,24,28],compil:[1,2,5,6,7,10,13,14,17,23,28],complement:5,complet:[24,28],complex:[6,7,13,15,18,28],complic:[8,9,17],compon:[0,1,25],compos:[10,14],comprehend:28,comprehens:28,compris:3,comput:[7,15,18,19,28,29],computexgradientgray8:28,concept:[0,1,2,5,8,9,10,11,13,14,15,16,18,19,22,28],concept_check:[10,28],concept_map:4,conceptc:4,conceptu:13,conclus:[11,22],concret:[6,28],condit:[15,18],confer:18,consid:[1,3,6,13,19,29],consist:[2,15,23,28],const_iterator_typ:14,const_point:1,const_refer:[1,8,10,13,14,28],const_t:[6,8,9,10,14,15,28],const_view:[9,28],const_view_t:[6,9],constant:[10,12,13,17,18,28],constexpr:[8,28],construct:[1,4,5,6,7,8,9,10,12,13,14,17,28],constructor:[1,6,7,9,17,28],consult:24,contain:[1,2,3,6,7,9,13,14,24,28],content:[11,20,27],context:[19,24],contigu:2,conveni:8,convent:[22,28],convers:[1,13,14,15,24],conversionpolici:24,convert:[1,2,7,8,10,12,13,14,24,27,28],convolut:[10,20,22],convolv:[7,19],coord:28,coord_t:[9,10,15],coordin:[15,16,24,28],copi:[1,2,6,7,8,9,10,13,15,17,24,28,29],copy_and_convert_pixel:[10,28],copy_pixel:[6,7,10,24,28],copyabl:10,copyconstruct:[2,4],copyconstructibleconcept:14,cordelia:18,corner:[7,10,18,28],correct:28,correctli:[4,17],correspond:[1,2,5,8,10,14,19,28],cost:5,could:[6,7,10,14,15,19,24,28],count:7,counter:28,counterpart:24,coupl:24,cours:[15,24],cover:18,cpp:[3,22],creat:[1,3,6,7,8,12,13,14,15,22,24],create_with_margin:7,current:[3,6,14,15,24,28],curvatur:[18,20],custom:[1,10,15],d_channel_t:28,data:[1,5,8,9,10,24,25,28],dave:17,deal:28,dealloc:28,debug:28,decent:24,declar:28,decrement:15,dedic:[11,20],deep:[6,9,17,28],deeper:18,default_color_convert:10,default_color_converter_impl:8,defaultconstruct:4,defaultconstructibleconcept:14,defin:[0,1,2,3,4,6,10,12,13,14,15,16,17,22,24,28],definit:[3,27],degrad:28,degre:28,delai:15,deleg:10,delet:9,demand:24,demonstr:[10,24,28],denot:[14,17,28],depend:[19,23,24],depth:[0,6,7,10,12,14,25,28,29],deref:[10,15],deref_compos:14,deref_t:8,derefer:[8,28],dereferenc:[7,8,10,12,14,15,17],dereference_iterator_adaptor:14,deriv:[10,18,20],derived_image_typ:[12,28],derived_iterator_typ:[12,28],derived_pixel_reference_typ:[12,28],derived_view_typ:[12,28],describ:[0,2,4,11,15,16,20,24],descript:[24,25],design:[0,2,5,22,24,28],desir:28,despit:6,destin:[1,6,7,8,24,28],destroi:6,destructor:[9,28],det:18,detail:[2,6,14,24],detect:[20,28],detector:[20,22],determin:[14,15,18],develop:[10,21],devic:24,devicen_t:3,diagram:15,diff:14,differ:[1,6,13,14,15,17,18,19,24,28],difference_typ:[10,15],difficult:[0,28],dim:[6,9,28],dimens:[6,9,10,15,16,18,24,28],dimension:[7,9,10,15,16,28],direct:[12,14,15,18,19,24,28],directli:[7,13,15,17,24,28,29],directori:27,disadvantag:28,discrimin:18,discuss:0,disk:[6,8,28],dispatch:8,displai:24,distanc:[14,28],distinct:[1,13,18,28],distribut:13,dither:24,divis:14,do_swap:6,document:[0,4,19,20,24,28],doe:[1,7,10,12,17,23,28],doesn:[24,28],doing:[6,8,13],don:[6,8,9,10,12,13,15,28],done:[7,15,19,24,28],doubl:[8,28],down:[6,7,10],download:[10,23],draw:19,drawback:28,drive:24,dst:[1,2,7,8,10,24,28],dst_channel_t:28,dst_it:28,dst_pixel:28,dst_row_byt:28,dst_view:24,dstchannel:1,dstcolorspac:8,dstimag:7,dstp:[8,10],dstpixel:13,dstview:28,due:13,duplic:29,dure:[21,24],dxdx:18,dxdy:18,dydi:18,dynam:[11,12,14,15,22,24],dynamic_at_c:[2,13],dynamic_imag:[6,22,28],dynamic_image_al:[6,28],dynamic_x_step_typ:[6,10,14],dynamic_xy_step_transposed_typ:10,dynamic_xy_step_typ:[6,10],dynamic_y_step_typ:[10,15],each:[0,2,7,8,10,13,15,16,24,28],earli:[10,28],easi:[24,28],easier:[10,28],easili:28,edg:[18,28],effect:[19,28],effici:[0,7,10,14,15,28,29],either:[6,7,8,10,14,24,28],element:[2,3,10,11,13,14,19,28],element_const_reference_typ:[2,13],element_recurs:2,element_reference_typ:[2,13],element_typ:2,els:[8,15],email:24,enabl:24,encod:24,end:[0,7,9,10,15,24,28,29],enough:18,ensur:[10,28],entir:28,enumer:[24,28],epipolar:21,equal:[1,2,3,6,10,13,15,28],equal_pixel:10,equalitycompar:[1,2,4],equival:[2,6,10,14,15],error:[1,6,7,10,17,28],especi:6,essenti:0,establish:25,etc:[0,6,10,13,23,24,28],european:18,evalu:[12,14],even:[6,7,8,24,28,29],ever:7,everi:[5,6,10,14,15,25,28,29],everyth:8,exact:19,exactli:13,exampl:[1,2,3,4,6,8,10,11,12,13,14,15,17,19,24,25,28,29],except:[2,6,8,10,14,15,23,28],exclud:28,execut:[6,28],exercis:28,exist:[5,7,8,24,29],expect:24,expens:28,explan:[10,18,24],explicit:[6,13,28],explicitli:28,extend:[5,11,22,28],extending_gil__io_with_new_format:24,extens:[6,8,10,23,28,29],extern:24,extra:[7,10,13,28,29],extract:28,extrem:18,fact:[24,28],factori:[8,10,28],fail:28,fall:[7,10],fals:[8,12,15,28],familiar:28,far:28,fast:[10,15,28],faster:[1,5,9,15,28],fastest:7,featr:29,featur:[18,20,21,24,29],fetch:28,few:24,file:[6,8,23,24,28],file_nam:6,filenam:24,filesystem:24,fill:[2,7,10,13,15,24,28],fill_pixel:[7,10,24],fill_valu:9,filter:[15,20],find:[15,23],first:[0,1,2,3,6,7,8,10,13,15,21,24],first_argument_typ:10,firstbit:1,fit:13,five:[3,5,12],flat:19,flavour:24,flexibl:[1,6,12,29],flip:[10,14,28],flipped_left_right_view:10,flipped_up_down_view:10,float_on:1,float_zero:1,fly:14,focu:28,focus:28,folder:[19,22,24],follow:[0,1,2,3,5,6,7,9,10,12,13,15,16,18,24,25,27,28,29],for_each:[2,7,10,28],for_each_pixel:[7,10,28,29],for_each_pixel_posit:[10,28],form:[0,9,12,13,18,19,28],format:[13,23,28],format_tag:24,formattag:24,forward:14,forwardtraversalconcept:14,found:24,four:[15,28],fourth:7,frame:21,framework:24,frederik:18,free:[15,23,28],freeli:[7,10],frequent:15,friendli:[15,28],from:[0,1,5,6,7,8,12,13,14,15,18,22,23,24,28,29],fulfil:4,full:[6,13],fulli:[8,24,28],fun:10,function_requir:13,fundament:[1,15,21],fundamental_step:14,further:17,furthermor:[24,28],futur:29,gap:10,gaussian:[18,19],gener:[0,2,4,6,7,9,10,11,14,16,18,19,25],generate_pixel:10,geometri:21,get:[1,6,8,10,12,14,18,19,28],get_color:[2,7,8,13],get_info:24,get_num_bit:27,get_num_it:28,get_pixel_typ:27,get_read_devic:24,get_reader_backend:24,gil:[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,20,22,23,25,27,30],gil_function_requir:[2,7,10,28],github:23,give:[7,15,24],given:[0,2,6,8,9,10,12,13,14,15,17,18,28],glimps:28,global:28,goal:5,goe:28,going:15,good:[19,28],googl:21,gool:18,gradient:[18,19,22],grai:[7,8,18,27],graph:19,grate:17,gray16:24,gray16_image_t:[24,28],gray16_pixel_t:28,gray16_step_view_t:10,gray16c_view_t:28,gray1:[24,28],gray1_image_t:24,gray2:24,gray32s_pixel_t:28,gray32s_view_t:28,gray4:24,gray4_image_t:24,gray7:24,gray8:24,gray8_image_t:[6,24,28],gray8_pixel_t:[7,8,28,29],gray8_view_t:7,gray8c_loc_t:28,gray8c_view_t:28,gray8s_image_t:28,gray8s_pixel_t:28,gray8s_view_t:28,gray_alpha:24,gray_alpha_16:24,gray_alpha_8:24,gray_channel_t:7,gray_color_t:[7,8],gray_cs_t:7,gray_image_t:28,gray_layout_t:28,gray_pixel_t:28,gray_t:[3,7,8,12],gray_to_rgb:7,grayimage_histogram:[7,29],graypixel:7,grayscal:[7,8,10,12,14,15,28],grayview:[7,29],green:[7,10,13,17,29],green_t:[2,3,7,13],grid:28,group:[0,3],guarante:4,guid:[10,22,28],guidelin:24,gv8:7,half:28,half_x_differ:28,halfdiff_cast_channel:28,hand:[0,5,18,22,28,29],handl:28,happen:[6,18,28],hard:[12,24],hardli:28,harrismatrix:18,has:[2,5,6,7,9,10,12,14,15,24,28],hasdynamicxsteptypeconcept:[14,15],hasdynamicysteptypeconcept:15,hassl:28,hastransposedtypeconcept:15,have:[0,1,2,3,5,6,7,8,9,10,12,13,14,15,18,24,27,28,29],hcb:2,header:[23,24,27],heidelberg:18,height:[6,7,9,10,28,29],help:19,helper:12,here:[0,1,2,3,4,6,7,8,10,12,13,14,15,19,24,28],hessianmatrix:18,heterogen:[12,13,28],higher:8,hill:[18,19],his:24,hist:[7,29],histogram:22,homogen:[2,13,14,28],homogeneous_color_bas:[2,14],homogeneouscolorbaseconcept:[2,13,14],homogeneouscolorbasevalueconcept:2,homogeneouspixel:13,homogeneouspixelbasedconcept:[12,13],homogeneouspixelconcept:13,homogeneouspixelvalueconcept:13,hopefulli:[24,27],horizont:[7,12,14,15,19,28],how:[1,3,6,7,8,10,12,13,14,18,24,28],howev:[2,10,28],hpp:[6,8,22,23,24,27,28],hsl:27,hsv:27,html:10,http:[10,23,30],ident:[7,8],ifstream:24,ignor:[13,28],illustr:[6,7,28],imag:[0,5,11,13,14,16,18,19,21,23,25,27,29],image_read_info:24,image_read_set:24,image_t:[6,24],image_typ:[8,12,27,28],image_view:[6,9,10,28],image_write_info:24,imageconcept:[6,7,9,12],imagemagick:24,imagetyp:6,imageviewconcept:[6,7,9,10,12,28],imageviewtyp:6,imagin:19,img:[6,7,9,10,15,24,28,29],img_view:8,immut:[6,9,10,12,14,15,25,28],impact:[10,28],implement:[1,2,6,8,10,13,14,15,17,18,23,24],impos:1,improv:[27,28],in1:28,in2:28,in_buff:24,inaccuraci:24,inc:14,includ:[4,6,23,24,27,28],incompat:[1,6,7,24,28],incomplet:24,incorrect:28,incorrectli:17,increas:10,increment:[14,15,28],independ:[15,24,28],index:[2,10,13,15,24,28,29],indexed_imag:27,indic:[1,12,15,19,25,28],indica:25,ineffici:6,info:24,inform:[1,15,24],inher:14,inherit:13,initi:[7,13,21,28],inlin:[6,8,28],inner:28,input:[10,19,28],insid:[6,7,8,10,15,16,28],instal:[22,24],instanc:[6,8,14,24,28],instanti:[6,10,15,28],instead:[1,2,9,28],instruct:28,instrument:5,int_:2,integ:[1,7,10,15,24,28],integr:[1,3,12,14,25,28],intel:15,intens:[1,18,19],interest:18,interfac:15,interleav:[0,6,7,8,9,10,12,13,14,15,25,28,29],interleaved_ptr:22,interleaved_ref:22,interleaved_view:[10,24,28],intermedi:7,intern:[14,18,29],internet:8,interpret:[3,10],introduc:24,invari:18,invert:8,invert_pixel:17,invok:[2,6,7,8,10,12,14,15,28],involv:28,ios:24,ios_bas:24,is_1d_travers:[10,15],is_bit_align:27,is_homogen:27,is_iterator_adaptor:14,is_mut:[1,8,13,14,28],is_pixel:13,is_planar:[12,13],is_sam:[6,7,13],is_similar:27,ismut:12,isplanar:[9,12],isstep:12,isstepx:12,issu:[17,28,29],isxstep:12,isystep:12,iter:[1,2,5,7,8,9,10,11,13,17,22,25,29],iterator_adaptor_get_bas:14,iterator_adaptor_rebind:14,iterator_from_2d:[10,15],iterator_is_mut:14,iterator_t:24,iterator_trait:[13,17,28],iterator_typ:12,iterator_type_from_pixel:12,iteratoradaptorconcept:14,its:[1,3,6,7,9,12,13,14,15,27,28],itself:[7,13],jiri:18,journal:18,jpeg:[8,28],jpeg_dynamic_io:6,jpeg_lib:24,jpeg_read_imag:[6,7,28],jpeg_tag:24,jpeg_wiki:24,jpeg_write_view:[6,7,28],jpg:[7,24,28],just:[7,8,9,12,13,15,24,27,28],kadir:18,keep:[0,14,28],kei:18,kernel:[7,20],kind:24,know:24,krystian:18,kth_element_const_reference_typ:2,kth_element_reference_typ:2,kth_element_typ:[2,13],kth_semantic_element_const_reference_typ:2,kth_semantic_element_reference_typ:2,kth_semantic_element_typ:[2,13],lab:27,lack:[24,28],laid:7,lambda:[7,29],larg:24,larger:7,largest:7,last:[10,13,24,28],lastli:17,later:[2,15],latest:23,latter:[7,13],layout:[2,5,11,12,13,14,22,25,28],layout_t:2,least:[6,28],leav:28,lectur:22,left:[7,10,14,15,24,28,29],let:[8,18,19,28,29],level:[1,6,24,28],lib:24,libjpeg:[23,24],libpng:[23,24],librari:[0,5,8,10,11,20,23,24,27,29],libraw:24,libtiff:24,lightweight:[7,10,15,28],like:[0,6,7,8,12,13,14,18,19,23,24,28],limit:[5,6],line:28,linear:[1,6],linearli:[1,28],link:[23,24,30],list:[11,20,24],littl:[13,19],live:8,load:[6,28],loc2:15,loc:15,local:24,locat:[5,8,9,10,11,12,13,14,16,22,25],locator_t:28,locator_typ:12,look:[8,18,19,24,28],loop:[10,15,28],lossi:[1,13],lot:[24,28],lower:24,lubomir:30,luc:18,lumin:19,luminos:[7,28,29],luminosity8bit_hist:29,luminosity_hist:29,luminosity_histogram:7,macro:[24,29],made:27,magnitud:28,mai:[0,1,3,4,6,7,8,10,13,14,15,28],main:27,maintain:[27,28],make:[0,6,7,8,10,15,24,28],make_scanline_read:24,make_step_iter:14,mandel:28,mandel_grad:28,mandelbrot:[8,14,15,22,28],mandelbrot_fn:28,mani:[5,6,9,10,24,28],manipul:5,manual:24,map:[1,3,7,13],margin:7,mark:0,mata:18,match:[1,10,17,24,28],matric:[18,19],matrix:[18,19],matter:18,max:1,max_el:2,max_valu:1,maximum:1,mayb:17,mean:[6,7,9,15,19,23,28],meant:24,measur:[6,15,28],mechan:[6,8,15,28],median:19,member:[8,14,17,24],memmov:[7,10],memori:[0,2,3,7,13,14,15,28,29],memory_based_2d_loc:15,memory_based_step_iter:[14,15],memorybasediteratorconcept:[14,15],memunit:[14,15],memunit_adv:14,memunit_advanc:14,memunit_advanced_ref:14,memunit_dist:14,memunit_step:14,mention:24,meta:28,metafunct:[2,4,10,11,13,14,15,16,22,27,28],metaprogram:24,method:[7,8,10,14,15,28],might:[18,19,24,28],mike:18,mikolajczyk:18,mileston:24,min:1,min_el:2,min_valu:1,mind:5,minimum:1,minisblack:24,minor:5,miss:28,mitig:28,mix:7,mode:[24,28],model:[0,4,5,6,7,8,12,17,28],modern:[24,28],modifi:[10,13,14,16,28],modul:[6,8],moment:18,monkei:7,monkey_transform:7,mono:24,moravec:18,more:[1,2,4,6,7,8,9,10,12,13,14,15,24,28],most:[2,4,8,9,10,13,15,16,23,24,28],motiv:1,move:[10,15,18,24,28],mp11:28,mp_list:28,mpl:[2,3,6,12,13,14,24],much:28,multi:24,multipl:[7,10,15,28],multipli:[1,14,28],must:[2,4,10,13,14,15,17,28],mutabl:[1,9,10,12,13,14,15,17,25,28],mutable_forwarditeratorconcept:14,mutablechannelconcept:1,mutablecolorbaseconcept:[2,13],mutablehomogeneouscolorbaseconcept:[2,13],mutablehomogeneouspixelconcept:[7,13],mutableimageviewconcept:[9,10,28],mutableiteratoradaptorconcept:14,mutablepixelconcept:[7,13,17],mutablepixeliteratorconcept:14,mutablepixellocatorconcept:[10,15],mutablerandomaccess2dimageviewconcept:10,mutablerandomaccess2dlocatorconcept:15,mutablerandomaccessiteratorconcept:14,mutablerandomaccessndimageviewconcept:[9,10],mutablerandomaccessndlocatorconcept:15,mutablestepiteratorconcept:[14,15],my_any_image_t:6,my_color_convert:8,my_color_converter_impl:8,my_img_typ:[24,28],my_reference_proxi:17,my_valu:17,my_view:7,my_virt_view_t:28,myimg:6,myit:17,n2081:4,name:[7,13,15,19,22,28,29],namespac:[2,6,17,24,27,28],nativ:[1,28],natur:15,navig:[10,14,15],necessari:[14,15,17,24,28],need:[1,4,7,8,10,12,13,14,15,24,27,28],neg:14,negat:10,neighbor:[15,28],neighborhood:15,neighbour:10,nest:[10,28],never:[6,7,28],new_dim:9,next:[8,10,24,28,29],nice:28,noisi:18,non:[7,10,12,13,15,17,24,25,28],none:[24,28],normal:28,note:[0,1,2,6,7,9,10,13,18,24,28],noth:13,notic:[2,7,18,28],notion:28,now:[18,24,28],nth_channel_deref_fn:14,nth_channel_view:[7,10,28,29],nth_channel_view_typ:10,nth_channel_x_gradi:28,num_channel:[6,10,12,13,28],num_dimens:[10,15,16],number:[2,6,7,10,13,14,15,18,28],numbit:1,numer:[10,18,22],numeric_limit:1,obj:6,object:[6,8,10,12,14,15,17,24,25,28,29],obtain:[15,28],occupi:13,off:28,offer:15,offset:[1,14,15,28],ofstream:24,often:[3,6,13,28],old:28,onc:[0,5,10,28],one:[2,4,6,7,8,10,12,13,14,15,19,24,28],ones:[6,8,13,18],onli:[1,2,6,7,8,10,13,14,15,17,18,23,24,27,28,29],onlin:24,open:6,oper:[1,2,4,6,8,9,10,13,14,15,16,17,22,24,25,28,29],oppos:[7,10,12,25,28],optim:[5,7,10,15,28],option:[0,8,18,22,24,28],order:[0,2,3,6,7,10,12,13,15,18,23,25,28,29],organ:[12,13,15,25],origin:[6,10,28,30],other:[2,4,8,13,14,15,18,19,24,25,28,29],otherwis:[8,13],our:[6,7,8,28],out:[24,28],out_buff:24,outdoor:18,output:28,outsid:28,over:[1,9,10,13,14,18,25,28],overhead:[6,28],overlai:18,overload:[6,10,17,28],overrid:[7,8,15],overview:[20,22],own:[4,8,9,10,15,22,24,28],ownership:[9,28],pack:[9,13,14,28],packed_channel_refer:1,packed_channel_valu:1,packed_dynamic_channel_refer:1,packed_image1_typ:12,packed_image2_typ:12,packed_image3_typ:12,packed_image4_typ:12,packed_image5_typ:12,packed_image_typ:12,packed_pixel:[2,13,14,22],packed_pixel_typ:13,pad:[0,7,9,15],page:24,pair:[2,13,28],pairwis:[1,10,13],palett:24,paper:[4,18],paramet:[0,1,5,6,7,8,9,10,14,15,17,24,28],parent:17,part:[24,29],partial:24,particular:[6,18,28],pass:[6,8,10,28],past:10,patch:18,path:[6,24],pattern:[1,7,12,28],peopl:27,per:[6,10,14,15,28],percent:24,perform:[6,8,10,14,15,22,28],permut:2,physic:[1,2,3,7,13],pick:24,pipe:28,pix_buff:13,pix_it:13,pixel1:13,pixel2:13,pixel:[0,1,2,3,4,5,6,8,9,11,16,17,19,22,25,29],pixel_2d_locator_bas:15,pixel_bit_s:27,pixel_refer:12,pixel_reference_typ:12,pixel_value_typ:12,pixelbasedconcept:[12,13,14,28],pixelconcept:[4,7,8,10,12,13,14,15],pixelconvertibleconcept:13,pixeldata:14,pixeldereferenceadaptorconcept:[8,10,14,15,28],pixeliteratorconcept:[10,12,14,15],pixellocatorconcept:[10,15],pixelrefer:12,pixelscompatibleconcept:[10,13],pixelvalueconcept:[8,9,10,13,14,15],place:28,plain:14,planar:[0,2,6,7,9,10,12,13,14,15,17,24,25,28,29],planar_pixel_iter:[14,15],planar_pixel_refer:[13,17],planar_rgb_view:[10,28],plane:[0,7,10,19,28],platform:[15,22],pleas:[18,24],plot:19,plu:15,png_lib:24,png_test_fil:24,png_wiki:24,pnm_wiki:24,point2dconcept:[15,16],point:[0,1,6,10,11,12,13,15,18,22,24,25,28],point_t:[6,9,10,15,24,28],point_typ:10,pointer:[1,7,8,10,13,14,15,24,25,28],pointndconcept:[10,15,16],polici:[0,10,29],popular:23,posit:[14,15,28],position_iter:14,possibl:[6,10,13,24,28],potenti:[0,24],pow:28,power:[6,7,18,28],practic:[6,28],pre:28,precis:1,prefix:2,presenc:0,present:[28,29,30],pretend:14,previou:[0,6],previous:[10,28],price:12,privat:[8,10,15,24,28],probabl:24,problem:[12,17,28],process:[0,10,21,22,28],processor:28,produc:19,product:[28,29],profil:8,program:[4,24,28,29],project:[0,21,23],propag:[10,28],proper:28,properli:[1,2,7,8,24,28],properti:[12,13,22,28],propos:4,provid:[0,1,2,3,5,6,8,9,10,12,13,14,15,16,17,19,24,27,28,29],proxi:[1,2,13],ptr:7,ptrdiff_t:[6,10,14,15,28],pull:14,purpos:13,put:[19,28],quadrant:29,qualifi:17,qualiti:[8,24],queri:28,r565:13,rais:28,random:[3,6,14,15,28],randomaccess2dimageconcept:9,randomaccess2dimageviewconcept:10,randomaccess2dlocatorconcept:15,randomaccessndimageconcept:9,randomaccessndimageviewconcept:10,randomaccessndlocatorconcept:[10,15],randomaccesstraversalconcept:[10,14,15],randomaccesstraversaliteratorconcept:14,rang:[1,2,9,10,28],range_c:3,rare:[9,28],rather:24,raw:[5,15,28],raw_wiki:24,rbegin:10,rbg323:24,rdbuf:24,read:[0,8,10,12,13,14,15,28],read_and_convert_imag:24,read_and_convert_view:24,read_imag:24,read_image_info:24,read_view:24,read_xxx:24,reader:[24,28],reader_bas:24,reader_t:24,real:[17,28],realiz:28,rebind:14,recommend:[0,24],recreat:[6,7,9],rectangular:[10,28],recurs:[2,14,28],red:[0,1,2,7,13,14,17],red_in_cmyk16:13,red_in_rgb8:13,red_t:[2,3,13],redefin:8,ref2:7,ref:[7,13],refer:[1,2,7,8,10,12,13,14,15,18,22,24,25,28],refin:16,regardless:28,region:[20,22,28],regist:28,regular:[1,2,4,9,10,13,15,16],rel:[15,28],relat:[4,12,28],releas:21,relev:24,remain:8,rememb:[15,17],remov:[24,28,29],remove_refer:14,rend:10,repeat:15,replac:12,repres:[0,15,17,24,28],represent:[0,5,22,28],request:24,requir:[1,2,4,6,8,9,10,13,14,15,22,23,24,28],resampl:10,rescal:22,resembl:[6,10],resid:28,resiz:[10,22],resolut:[5,6],respect:[7,13,28],respons:18,rest:[12,28],restrict:24,result:[0,2,5,6,7,8,10,12,13,14,15,18,24,28],result_typ:[4,6,8,10,14,28],reus:28,reverse_iter:10,review:[24,27],rewrit:28,rewritten:29,rgb16:24,rgb16_image_t:[10,28],rgb16c_planar_view_t:28,rgb222:28,rgb32f_planar_step_ptr_t:[12,25],rgb32f_planar_view_t:7,rgb32fc_view_t:28,rgb32s_pixel_t:28,rgb32s_view_t:28,rgb565:13,rgb565_channel0_t:13,rgb565_channel1_t:13,rgb565_channel2_t:13,rgb565_pixel_t:13,rgb64_image_t:8,rgb64_pixel:8,rgb64_pixel_ptr_t:8,rgb64_pixel_t:8,rgb8:[13,24],rgb8_image_t:[6,24,28],rgb8_pixel_t:[7,13,28],rgb8_planar_ptr_t:14,rgb8_planar_ref_t:[7,13],rgb8_planar_view_t:12,rgb8_ptr_t:10,rgb8_step_view_t:6,rgb8_view_t:[6,7],rgb8c_planar_ptr_t:[7,14],rgb8c_planar_ref_t:[7,13],rgb8c_ptr_t:10,rgb8c_view_t:[6,28],rgb:[0,1,2,7,8,10,12,13,14,24,25,28,29],rgb_channel_t:7,rgb_cs_t:7,rgb_full:13,rgb_layout_t:[7,8,13],rgb_planar_pixel_iter:17,rgb_t:[3,7,13,14],rgba16:24,rgba8:24,rgba8_image_t:24,rgba:[0,3,12,25,27],rgba_image_t:24,rgba_layout_t:[3,7],rgba_t:3,rgbpixel:7,rgbtograi:29,right:[7,10,14,15,28],rise:15,rotat:[6,10,28],rotated180_view:[6,7,10],rotated180_view_fn:6,rotated90ccw_view:[10,28],rotated90cw_view:[10,28],row:[0,7,9,10,13,14,15,24,28,29],row_begin:[10,28],row_end:10,rowsiz:10,rpv32:7,rule:23,run:[0,1,5,6,7,10,21,22],runtim:6,runtime_imag:[24,28],rview:10,said:6,sake:10,same:[1,2,3,6,7,8,10,13,15,16,18,19,24,28],sametyp:[1,2,4,10,13,14,16],sampl:[15,22,24,28,29],satisfi:[2,4,9,10,15,28],sav:6,save:[6,24,28],save_180rot:6,scale:28,scanlin:24,scanline_read:24,scanline_read_iter:24,scenario:[2,28],schaffalitzki:18,scharr:19,scharrx:19,schmid:18,scoped_channel_valu:1,sean:17,second:[0,1,7,13,15,17,18,24,28,29],second_argument_typ:10,section:[0,2,10,11,20,24,27],see:[2,4,8,10,14,15,24,28],seek:24,select:6,semant:[2,3,13,28],semantic_at_c:[2,7,13],send:24,separ:[0,8,10,18,28],sequenc:[1,3],serv:24,set:[0,1,3,4,6,7,8,9,10,13,14,15,24,28],set_step:14,sever:[5,14,24,28],shallow:[6,7,10,14,17,28],shape:19,share:[6,13,24],sharper:19,she:24,shift:1,shortli:29,should:[6,15,18,23,24,28],show:[7,24,28],shown:[7,28],side:28,sigma:19,sign:[12,25,28],signific:10,similar:[1,10,14,15,22,24,28],similarli:[9,14],simpl:[12,15,19,24,28,29],simpler:[18,24,29],simplest:[19,28],simpli:[7,8,15,18,19,28],simplic:28,simplifi:[7,18,28],simultan:28,sinc:[6,7,13,14,24,27,28,29],singl:[6,10,14,19,24,28],size1:12,size2:12,size3:12,size4:12,size5:12,size:[2,3,6,7,10,13,14,15,24,28],size_t:[2,6,9,10,13,15,16],size_typ:[6,10],sizeof:13,skeleton:24,skip:[10,14,28,29],slightli:[8,28],slow:28,slower:[15,28],small:[18,24,27],smaller:7,sobel:19,softwar:29,solut:17,some:[0,4,6,7,8,10,12,13,14,15,17,24,28],sometim:[1,10,13,14,15,17,24,28],somewher:8,soon:24,sort:19,sourc:[1,6,7,8,10,24,25,28,29,30],space:[0,2,5,6,7,10,11,13,14,22,24,27,28,29],special:[8,13,25,28],specif:[0,5,22,24,28],specifi:[0,1,3,5,6,8,9,12,14,22,24],speed:[0,5,6,10,28],spirit:15,springer:18,sr8wjg0pcee:30,src1:10,src1_it:28,src2:10,src2_it:28,src:[1,2,6,7,8,10,24,28],src_b:28,src_g:28,src_it:28,src_loc:28,src_pix_ref:8,src_pixel:28,src_r:28,src_row_byt:28,srcchannel:1,srccolorspac:8,srcconstrefp:8,srcp:8,srcpixel:13,srcview:[7,8,10,28],srowbyt:29,stabl:18,stage:10,standalon:27,standard:[3,4,10,12,14,15],start:[10,13,15,24,28],state:10,statement:[6,28],static_:2,static_assert:[6,7,12,13],static_copi:2,static_equ:2,static_fil:[2,7,28],static_for_each:[2,28],static_gener:[2,28],static_max:2,static_min:2,static_transform:[2,14,28],std:[1,2,6,7,9,10,12,13,14,15,17,24,28,29],step1:7,step2:7,step3:7,step4:7,step5:7,step:[6,10,12,15,20,25,28],step_iterator_t:12,stepanov:17,stephen:18,stepiter:15,stepiteratorconcept:[14,15],still:28,stl:[2,5,6,9,15,17],stlab:10,store:[6,7,15,24,28],straightforward:[10,24],stream:24,strength:19,stretch:19,string:[6,24],stringstream:24,strip:24,strongli:24,struct:[1,2,3,6,8,10,12,13,14,15,16,17,24,28],structur:[0,6,10,11,18,20,22,28],studio:28,sub:[1,17,24,27],subclass:[6,14,15],subimag:28,subimage_view:[7,10,24,28,29],subject:24,suboptim:28,subsampl:[10,14,28],subsampled_view:[7,10,28,29],substitut:4,succinct:10,suffici:[15,23],suffix:25,suggest:[17,27],suit:24,suitabl:28,sum:18,summer:21,suppli:[8,10,14,15,24],support:[0,1,6,7,8,10,12,14,22,28,29],supported_image_format:24,suppos:[6,7,8,28],sure:24,swap:[4,15,17],swappabl:[1,2,4],symmetr:13,synopsi:[10,15],syntact:4,syntax:4,synthet:[8,22,28],system:[24,28],tabl:[11,20,24],tag:[24,25],tag_t:24,take:[2,6,7,8,9,10,14,15,17,24,28,29],taken:28,targa_wiki:24,target:[5,24,28],task:28,technic:[11,22],techniqu:[6,24],tell:23,templat:[1,2,3,4,6,7,8,9,10,12,13,14,15,16,17,24,28,29],temporari:[17,28],term:[16,18],test:[22,25],test_imag:24,text:24,than:[2,6,7,13,14,15,24,28],thank:[24,27],thei:[1,2,3,5,6,7,8,10,12,13,14,15,18,19,28],them:[1,4,6,9,10,12,13,24,28],therefor:1,thi:[0,1,2,4,6,7,8,10,12,13,14,15,17,18,19,24,25,27,28,29,30],thing:[7,19,24],think:28,third:24,thorough:24,those:[13,19],though:[6,7,19,28],three:[1,13,14,18,19,28],threshold:18,through:[7,15,24,28],thrown:28,thu:[1,2,3,8,15],tif:24,tiff_base_tag:24,tiff_extension_tag:24,tiff_graphicsmagick_test_fil:24,tiff_lib:24,tiff_lib_tiff_test_fil:24,tiff_t:24,tiff_tag:24,tiff_wiki:24,tile:24,time:[0,1,2,5,6,7,8,10,14,22],timor:18,tinn:18,tmp:[14,17],todo:26,togeth:[0,3,13,28],toll:[6,28],too:27,toolbox:[22,24],top:[0,7,10,12,15,24,28,29],top_left:10,total:[10,15],trace:18,track:[10,14,28],transform:[1,2,6,8,10,18,22],transform_pixel:[10,28],transform_pixel_posit:[10,28],transpos:[10,15,28],transposed_typ:[10,15],transposed_view:10,travers:[9,10,14,15,24,25,28],treat:[6,28],tricki:17,trickier:28,trigger:[6,28],trivial:25,troubl:24,true_:[12,14],turn:6,tutori:[8,10,15,22],tuytelaar:18,tweak:19,twice:28,two:[0,1,2,3,6,7,9,10,13,14,15,16,18,19,21,24,28],type:[0,1,2,3,4,5,6,7,9,10,13,14,15,16,17,22,24,27,28,29],type_from_x_iter:12,typedef:[1,6,7,8,10,12,13,14,17,24,28],typenam:[1,2,3,4,6,7,8,9,10,12,13,14,15,16,17,24,28,29],typic:[1,6,8,10],ud_fud:10,uint16_t:[1,13],uint8_t:[1,18,29],unari:[14,28],unary_compos:14,unary_funct:14,unaryfunctionconcept:[10,14],unchang:28,unclear:15,under:[18,24],underli:[6,10,14,24],understand:[1,18,19,24],unfamiliar:28,unfortun:28,uniformli:6,uninitialized_copi:10,uninitialized_copy_pixel:10,uninitialized_fil:10,uninitialized_fill_pixel:10,uniqu:3,unit:[14,15,24],unless:19,unlik:[9,13],unnam:3,unnecessari:[7,13,28],unpack:13,unrel:29,unrol:28,unset:10,unsign:[6,7,9,10,12,13,14,25,28],unspecifi:4,until:18,unus:[13,28],unusu:28,upon:[6,8,10,12,14,15,17],upper:29,upsid:[6,10],usag:[19,24],use:[1,2,4,7,8,10,12,13,15,17,19,23,24,28],use_default:12,used:[2,3,4,5,6,7,9,13,14,15,16,18,19,24,25,28],useful:[8,9,14,15,28],user:[0,4,8,10,15,24,27,28],uses:[2,6,10,12,14,15,16,24,28],using:[1,2,3,6,7,8,9,10,12,13,15,22,24,28,29],using_io:24,usual:[14,18,19,24],val:10,valid:[1,10,28],valu:[0,1,2,3,6,7,8,9,10,12,13,14,15,16,17,18,19,24,25,28],value_typ:[1,8,9,10,13,14,15,16,24,28],valueless:6,van:18,vari:[0,3,28],variabl:[0,28,29],variant2:6,variant:[6,24,28],variat:[0,24],varieti:[22,28],variou:24,vector3_c:13,vector4:3,vector4_c:3,vector:[24,28],veri:[9,12,18,28,29],version:[10,14,15,23,24,29],vertic:[12,14,15,19,28],via:[6,10],video:[0,22,28],view1:10,view2:10,view:[5,9,11,13,14,15,22,24,25,29],view_is_mut:12,view_t:[6,7,9,10,12,24],view_typ:12,view_type_from_pixel:12,viewer:24,viewscompatibleconcept:[7,10],viewtyp:6,virtual:[5,8,12,14,15,24],virtual_2d_loc:[15,28],vision:[0,18],visit:[10,15],visual:28,vol:18,wai:[2,13,17,19,24,25,28],walk:[24,28],want:[7,8,14,15,24,28],warn:28,watch:30,web:4,websit:24,weight:[18,20],well:[2,13,24,28],were:[21,28],what:[6,19,20,24,28],when:[2,7,8,9,10,14,15,17,18,19,24,28],where:[1,2,7,9,10,12,13,14,15,16,23,24,25,28],wherea:[0,2,6,19,24,28],whether:[1,10,12,14,15,28],which:[0,1,2,3,6,7,8,9,10,12,14,15,16,19,23,24,25,27,28],who:27,whose:[0,2,10,12,13,14,22,28],why:28,width:[6,7,9,10,15,28,29],window:[18,24],within:10,without:18,word:[0,9,10,14,19,28],work:[0,5,6,7,8,10,13,17,18,22,28,29],worth:[7,24,28],would:[0,6,14,19,24,28],wrap:[6,10,14],wrapper:[14,15],write:[0,5,6,7,10,17,22,28],write_view:24,writer:24,written:[15,19,24,28,29],wstring:24,www:30,x_at:[10,15],x_coord_t:[6,9,10,15],x_diff:15,x_gradient:[22,28],x_gradient_obj:28,x_gradient_rgb_luminos:28,x_gradient_unguard:28,x_iter:[9,10,13,15,24,28],x_luminosity_gradi:28,x_min:28,xbm:24,xgradientgray16_gray32:28,xgradientplanarrgb8_rgb32:28,xgradientrgb8_bgr16:28,xiter:[12,15],xpm:24,xxx:24,xxx_all:24,xxx_and_convert_xxx:24,xxx_read:24,xxx_tag:24,xxx_write:24,xy_at:[10,15,28],xy_loc:[10,28],xy_locator_t:12,xyz:27,y_at:[10,15],y_coord_t:[6,9,10,15],y_distance_to:15,y_gradient:28,y_iter:[10,15,28],y_min:28,ycbcr:24,ycck:24,yellow:18,yet:[0,24,28],you:[7,8,12,17,24,28],your:[8,17,22,23,24,28],yourself:24,youtub:30,zero:[13,18,28],zisserman:18,zlib:24},titles:["Basics","Channel","Color Base","Color Space and Layout","Concepts","Conclusions","Dynamic images and image views","Examples","Extending","Image","Image View","Design Guide","Metafunctions","Pixel","Pixel Iterator","Pixel Locator","Point","Technicalities","Affine region detectors","Basics","Image Processing","Overview","Boost Generic Image Library","Installation","IO extensions","Naming Conventions","Numeric extension","ToolBox extension","Tutorial: Image Gradient","Tutorial: Histogram","Tutorial: Video Lecture"],titleterms:{"new":[8,24],And:24,Using:[7,24,28],acknowledg:27,adaptor:14,affin:18,algorithm:[1,2,10,13,18,28],align:12,avail:18,base:[2,12],basic:[0,19],being:18,bit:12,bmp:24,boost:22,buffer:24,canva:7,channel:[1,8],code:28,color:[2,3,8,28],compat:5,compil:24,compon:12,concept:4,conclus:[5,28],concret:25,convent:25,convers:[8,28],convolut:19,core:22,creat:[10,17,28],curvatur:19,defin:8,derefer:14,deriv:[12,19],design:11,detect:18,detector:18,document:22,dynam:6,equival:28,exampl:[7,22],exist:12,extend:[8,24],extens:[5,22,24,26,27],filter:19,first:28,flexibl:5,folder:27,format:24,from:10,fundament:14,gener:[5,22,24,28],gil:[24,28,29],glue:28,gradient:28,guid:11,harri:18,hessian:18,histogram:[7,29],homogen:12,imag:[6,7,8,9,10,12,15,20,22,24,28],implement:[28,29],instal:23,interfac:[24,28],iter:[12,14,15,28],jpeg:24,kernel:19,layout:3,lectur:30,level:7,librari:22,locat:[15,28],manipul:12,memori:[12,24],metafunct:12,model:[1,2,3,9,10,13,14,15,16],name:25,numer:26,oper:7,origin:29,other:10,over:15,overload:8,overview:[1,2,3,8,9,10,12,13,14,15,16,21,24,26,27],pack:12,perform:5,pixel:[7,10,12,13,14,15,28],platform:24,png:24,pnm:24,point:16,process:20,proxi:17,quickstart:22,raw:[10,24],read:24,refer:[17,27],region:18,resiz:7,run:[24,28],space:[3,8],specifi:28,step:[14,18],stl:[10,28],structur:27,style:10,support:24,symbol:24,targa:24,technic:17,test:24,tiff:24,time:28,toolbox:27,trait:12,transform:28,tutori:[24,28,29,30],type:[8,12,25],version:28,video:30,view:[6,7,8,10,12,28],virtual:28,weight:19,what:18,write:24}})
\ No newline at end of file
diff --git a/develop/doc/html/toolbox.html b/develop/doc/html/toolbox.html
index caf437b9d..9305f30dd 100644
--- a/develop/doc/html/toolbox.html
+++ b/develop/doc/html/toolbox.html
@@ -128,8 +128,8 @@ made suggestions for improvements.
    
     
    
     
    
     
   
 
\ No newline at end of file
diff --git a/develop/doc/html/tutorial/gradient.html b/develop/doc/html/tutorial/gradient.html
index a0b0f4602..df291113f 100644
--- a/develop/doc/html/tutorial/gradient.html
+++ b/develop/doc/html/tutorial/gradient.html
@@ -89,7 +89,7 @@ generic as we go along.  Let us start with a horizontal gradient and use the
 simplest possible approximation to a gradient - central difference.
    
 
    The gradient at pixel x can be approximated with the half-difference of its
 two neighboring pixels:
    
-
    D[x] = (I[x-1] - I[x+1]) / 2
+
    D[x] = (I[x-1] - I[x+1]) / 2
 
    
 
    
 
    For simplicity, we will also ignore the boundary cases - the pixels along the
@@ -162,7 +162,7 @@ gradient like this:
    
 {
   for (int y = 0; y < src.height(); ++y)
       for (int x = 1; x < src.width() - 1; ++x)
-          dst(x, y) = (src(x-1, y) - src(x+1, y)) / 2;
+          dst(x, y) = (src(x-1, y) - src(x+1, y)) / 2;
 }
 
    
 
    
@@ -183,7 +183,7 @@ addition and multiplication. Here is a faster version of the above:
    
       gray8s_view_t::x_iterator dst_it = dst.row_begin(y);
 
       for (int x=1; x < src.width() - 1; ++x)
-          dst_it[x] = (src_it[x-1] - src_it[x+1]) / 2;
+          dst_it[x] = (src_it[x-1] - src_it[x+1]) / 2;
   }
 }
 
    
@@ -211,7 +211,7 @@ loop:
    
 {
   for (int y = 1; y < src.height() - 1; ++y)
   {
-      gray8c_view_t::x_iterator src1_it = src.row_begin(y-1);
+      gray8c_view_t::x_iterator src1_it = src.row_begin(y-1);
       gray8c_view_t::x_iterator src2_it = src.row_begin(y+1);
       gray8s_view_t::x_iterator dst_it = dst.row_begin(y);
 
@@ -244,7 +244,7 @@ done with GIL locators:
    
 
       for (int x = 0; x < src.width(); ++x)
   {
-          (*dst_it) = (src_loc(0,-1) - src_loc(0,1)) / 2;
+          (*dst_it) = (src_loc(0,-1) - src_loc(0,1)) / 2;
           ++dst_it;
           ++src_loc.x(); // each dimension can be advanced separately
       }
@@ -278,7 +278,7 @@ reuse this offset:
    
 
    void y_gradient(gray8c_view_t const& src, gray8s_view_t const& dst)
 {
   gray8c_view_t::xy_locator src_loc = src.xy_at(0,1);
-  gray8c_view_t::xy_locator::cached_location_t above = src_loc.cache_location(0,-1);
+  gray8c_view_t::xy_locator::cached_location_t above = src_loc.cache_location(0,-1);
   gray8c_view_t::xy_locator::cached_location_t below = src_loc.cache_location(0, 1);
 
   for (int y = 1; y < src.height() - 1; ++y)
@@ -305,7 +305,7 @@ operation and the code is efficient.
    
 views, as long as they have the same number of channels. The gradient
 operation is to be computed for each channel independently.
    
 
    Here is how the new interface looks like:
    
-
    template <typename SrcView, typename DstView>
+
    template <typename SrcView, typename DstView>
 void x_gradient(const SrcView& src, const DstView& dst)
 {
   gil_function_requires<ImageViewConcept<SrcView> >();
@@ -314,8 +314,8 @@ operation is to be computed for each channel independently.
    
   <
     ColorSpacesCompatibleConcept
     <
-      typename color_space_type<SrcView>::type,
-      typename color_space_type<DstView>::type
+      typename color_space_type<SrcView>::type,
+      typename color_space_type<DstView>::type
     >
   >();
 
@@ -355,45 +355,45 @@ default).
    
 
    The body of the generic function is very similar to that of the
 concrete one. The biggest difference is that we need to loop over the
 channels of the pixel and compute the gradient for each channel:
    
-
    template <typename SrcView, typename DstView>
+
    template <typename SrcView, typename DstView>
 void x_gradient(const SrcView& src, const DstView& dst)
 {
   for (int y=0; y < src.height(); ++y)
   {
-      typename SrcView::x_iterator src_it = src.row_begin(y);
-      typename DstView::x_iterator dst_it = dst.row_begin(y);
+      typename SrcView::x_iterator src_it = src.row_begin(y);
+      typename DstView::x_iterator dst_it = dst.row_begin(y);
 
       for (int x = 1; x < src.width() - 1; ++x)
           for (int c = 0; c < num_channels<SrcView>::value; ++c)
-              dst_it[x][c] = (src_it[x-1][c]- src_it[x+1][c]) / 2;
+              dst_it[x][c] = (src_it[x-1][c]- src_it[x+1][c]) / 2;
   }
 }
 
    
 
    
 
    Having an explicit loop for each channel could be a performance problem.
 GIL allows us to abstract out such per-channel operations:
    
-
    template <typename Out>
-struct halfdiff_cast_channels
+
    template <typename Out>
+struct halfdiff_cast_channels
 {
-  template <typename T> Out operator()(T const& in1, T const& in2) const
+  template <typename T> Out operator()(T const& in1, T const& in2) const
   {
-      return Out((in1 - in2) / 2);
+      return Out((in1 - in2) / 2);
   }
 };
 
-template <typename SrcView, typename DstView>
+template <typename SrcView, typename DstView>
 void x_gradient(const SrcView& src, const DstView& dst)
 {
-  typedef typename channel_type<DstView>::type dst_channel_t;
+  typedef typename channel_type<DstView>::type dst_channel_t;
 
   for (int y=0; y < src.height(); ++y)
   {
-      typename SrcView::x_iterator src_it = src.row_begin(y);
-      typename DstView::x_iterator dst_it = dst.row_begin(y);
+      typename SrcView::x_iterator src_it = src.row_begin(y);
+      typename DstView::x_iterator dst_it = dst.row_begin(y);
 
       for (int x=1; x < src.width() - 1; ++x)
       {
-          static_transform(src_it[x-1], src_it[x+1], dst_it[x],
+          static_transform(src_it[x-1], src_it[x+1], dst_it[x],
               halfdiff_cast_channels<dst_channel_t>());
       }
   }
@@ -459,7 +459,7 @@ files for more on using such images.
    
 
    One way to compute the y-gradient is to rotate the image by 90 degrees,
 compute the x-gradient and rotate the result back.
 Here is how to do this in GIL:
    
-
    template <typename SrcView, typename DstView>
+
    template <typename SrcView, typename DstView>
 void y_gradient(const SrcView& src, const DstView& dst)
 {
   x_gradient(rotated90ccw_view(src), rotated90ccw_view(dst));
@@ -481,7 +481,7 @@ because of the memory access pattern; using 
    template <typename SrcView, typename DstView>
+
    template <typename SrcView, typename DstView>
 void nth_channel_x_gradient(const SrcView& src, int n, const DstView& dst)
 {
   x_gradient(nth_channel_view(src, n), dst);
@@ -523,15 +523,15 @@ and last column:
    
       gray8s_view_t::x_iterator dst_it = dst.row_begin(y);
 
       for (int x = 0; x < src.width(); ++x)
-          dst_it[x] = (src_it[x-1] - src_it[x+1]) / 2;
+          dst_it[x] = (src_it[x-1] - src_it[x+1]) / 2;
   }
 }
 
 void x_gradient(gray8c_view_t const& src, gray8s_view_t const& dst)
 {
   assert(src.width()>=2);
-  x_gradient_unguarded(subimage_view(src, 1, 0, src.width()-2, src.height()),
-                       subimage_view(dst, 1, 0, src.width()-2, src.height()));
+  x_gradient_unguarded(subimage_view(src, 1, 0, src.width()-2, src.height()),
+                       subimage_view(dst, 1, 0, src.width()-2, src.height()));
 }
 
    
 
    
@@ -547,7 +547,7 @@ rewrite it more compactly:
    
 {
   gray8c_view_t::iterator src_it = src.begin();
   for (gray8s_view_t::iterator dst_it = dst.begin(); dst_it!=dst.end(); ++dst_it, ++src_it)
-      *dst_it = (src_it.x()[-1] - src_it.x()[1]) / 2;
+      *dst_it = (src_it.x()[-1] - src_it.x()[1]) / 2;
 }
 
    
 
    
@@ -576,11 +576,11 @@ assign to each destination pixel the value of the half-difference of
 the horizontal neighbors of the corresponding source pixel.  If we
 abstract that operation in a function object, we can use GIL’s
 transform_pixel_positions to do that:
    
-
    struct half_x_difference
+
    struct half_x_difference
 {
-  int operator()(const gray8c_loc_t& src_loc) const
+  int operator()(const gray8c_loc_t& src_loc) const
   {
-      return (src_loc.x()[-1] - src_loc.x()[1]) / 2;
+      return (src_loc.x()[-1] - src_loc.x()[1]) / 2;
   }
 };
 
@@ -625,10 +625,10 @@ performs color conversion every time its pixels are accessed.
    
 color space to grayscale, but keep the channel depth the same. We do
 that by constructing the type of a GIL grayscale pixel with the same
 channel as the source, and color convert to that pixel type:
    
-
    template <typename SrcView, typename DstView>
+
    template <typename SrcView, typename DstView>
 void x_luminosity_gradient(SrcView const& src, DstView const& dst)
 {
-  using gray_pixel_t = pixel<typename channel_type<SrcView>::type, gray_layout_t>;
+  using gray_pixel_t = pixel<typename channel_type<SrcView>::type, gray_layout_t>;
   x_gradient(color_converted_view<gray_pixel_t>(src), dst);
 }
 
    
@@ -662,11 +662,11 @@ image in our x_grad
 provides global functions view and const_view that take an
 image and return a mutable or an immutable view of its pixels.
    
 
    Creating a generic version of the above is a bit trickier:
    
-
    template <typename SrcView, typename DstView>
+
    template <typename SrcView, typename DstView>
 void x_luminosity_gradient(const SrcView& src, const DstView& dst)
 {
-  using d_channel_t = typename channel_type<DstView>::type;
-  using channel_t = typename channel_convert_to_unsigned<d_channel_t>::type;
+  using d_channel_t = typename channel_type<DstView>::type;
+  using channel_t = typename channel_convert_to_unsigned<d_channel_t>::type;
   using gray_pixel_t = pixel<channel_t, gray_layout_t>;
   using gray_image_t = image<gray_pixel_t, false>;
 
@@ -698,13 +698,13 @@ planar or interleaved.  Single-channel (grayscale) images in GIL must
 always be interleaved. There are multiple ways of constructing types
 in GIL. Instead of instantiating the classes directly we could have
 used type factory metafunctions. The following code is equivalent:
    
-
    template <typename SrcView, typename DstView>
+
    template <typename SrcView, typename DstView>
 void x_luminosity_gradient(SrcView const& src, DstView const& dst)
 {
-  typedef typename channel_type<DstView>::type d_channel_t;
-  typedef typename channel_convert_to_unsigned<d_channel_t>::type channel_t;
-  typedef typename image_type<channel_t, gray_layout_t>::type gray_image_t;
-  typedef typename gray_image_t::value_type gray_pixel_t;
+  typedef typename channel_type<DstView>::type d_channel_t;
+  typedef typename channel_convert_to_unsigned<d_channel_t>::type channel_t;
+  typedef typename image_type<channel_t, gray_layout_t>::type gray_image_t;
+  typedef typename gray_image_t::value_type gray_pixel_t;
 
   gray_image_t ccv_image(src.dimensions());
   copy_and_convert_pixels(src, view(ccv_image));
@@ -739,7 +739,7 @@ view of the Mandelbrot set.  First, we need to create a function
 object that computes the value of the Mandelbrot set at a given
 location (x,y) in the image:
    
 
    // models PixelDereferenceAdaptorConcept
-struct mandelbrot_fn
+struct mandelbrot_fn
 {
   typedef point<ptrdiff_t>   point_t;
 
@@ -757,7 +757,7 @@ location (x,y) in the image:
    
   result_type operator()(const point_t& p) const
   {
       // normalize the coords to (-2..1, -1.5..1.5)
-      double t=get_num_iter(point<double>(p.x/(double)_img_size.x*3-2, p.y/(double)_img_size.y*3-1.5f));
+      double t=get_num_iter(point<double>(p.x/(double)_img_size.x*3-2, p.y/(double)_img_size.y*3-1.5f));
       return value_type((bits8)(pow(t,0.2)*255));   // raise to power suitable for viewing
   }
 private:
@@ -828,15 +828,15 @@ destination view and has an application operator taking a templated
 source view:
    
 
    #include <boost/gil/extension/dynamic_image/dynamic_image_all.hpp>
 
-template <typename DstView>
-struct x_gradient_obj
+template <typename DstView>
+struct x_gradient_obj
 {
   typedef void result_type;        // required typedef
 
   const DstView& _dst;
   x_gradient_obj(const DstView& dst) : _dst(dst) {}
 
-  template <typename SrcView>
+  template <typename SrcView>
   void operator()(const SrcView& src) const { x_luminosity_gradient(src, _dst); }
 };
 
    
@@ -844,7 +844,7 @@ source view:
    
 
    The second step is to provide an overload of x_luminosity_gradient that
 takes image view variant and calls GIL’s apply_operation passing it the
 function object:
    
-
    template <typename SrcViews, typename DstView>
+
    template <typename SrcViews, typename DstView>
 void x_luminosity_gradient(const any_image_view<SrcViews>& src, const DstView& dst)
 {
   apply_operation(src, x_gradient_obj<DstView>(dst));
@@ -953,8 +953,8 @@ code with different compilers.
    
     
    
     
    
     
   
 
\ No newline at end of file
diff --git a/develop/doc/html/tutorial/histogram.html b/develop/doc/html/tutorial/histogram.html
index d30129177..c323d8fcf 100644
--- a/develop/doc/html/tutorial/histogram.html
+++ b/develop/doc/html/tutorial/histogram.html
@@ -106,14 +106,14 @@ histogram (variable names have been changed and unrelated parts removed):
    
 
    
 
    
 
    GIL implementation
    
-
    template <typename GrayView, typename R>
+
    template <typename GrayView, typename R>
 void grayimage_histogram(GrayView& img, R& hist)
 {
-    for (typename GrayView::iterator it=img.begin(); it!=img.end(); ++it)
+    for (typename GrayView::iterator it=img.begin(); it!=img.end(); ++it)
         ++hist[*it];
 }
 
-template <typename View, typename R>
+template <typename View, typename R>
 void luminosity8bit_hist(View& img, R& hist)
 {
     grayimage_histogram(color_converted_view<gray8_pixel_t>(img),hist);
@@ -124,7 +124,7 @@ histogram (variable names have been changed and unrelated parts removed):
    
 even simpler:
    
 
    using boost::lambda;
 
-template <typename GrayView, typename R>
+template <typename GrayView, typename R>
 void grayimage_histogram(GrayView& img, R& hist)
 {
     for_each_pixel(img, ++var(hist)[_1]);
@@ -171,8 +171,8 @@ memory is allocated and no images are copied.
    
     
    
     
    
     
   
 
\ No newline at end of file
diff --git a/develop/doc/html/tutorial/video.html b/develop/doc/html/tutorial/video.html
index f870d31e9..a770e4353 100644
--- a/develop/doc/html/tutorial/video.html
+++ b/develop/doc/html/tutorial/video.html
@@ -82,8 +82,8 @@
     
    
     
    
     
   
 
\ No newline at end of file