[Test-list] svn:boost r82769 - in trunk/boost/gil/extension/toolbox: . color_converters color_spaces image_types metafunctions

Subject: [Test-list] svn:boost r82769 - in trunk/boost/gil/extension/toolbox: . color_converters color_spaces image_types metafunctions
From: chhenning_at_[hidden]
Date: 2013-02-06 20:37:50

Author: chhenning
Date: 2013-02-06 20:37:47 EST (Wed, 06 Feb 2013)
New Revision: 82769
URL: http://svn.boost.org/trac/boost/changeset/82769

Log:
Toolbox extension inital commit.
Added:
   trunk/boost/gil/extension/toolbox/
   trunk/boost/gil/extension/toolbox/color_converters/
   trunk/boost/gil/extension/toolbox/color_converters.hpp   (contents, props changed)
   trunk/boost/gil/extension/toolbox/color_converters/gray_to_rgba.hpp   (contents, props changed)
   trunk/boost/gil/extension/toolbox/color_converters/rgb_to_luminance.hpp   (contents, props changed)
   trunk/boost/gil/extension/toolbox/color_spaces/
   trunk/boost/gil/extension/toolbox/color_spaces.hpp   (contents, props changed)
   trunk/boost/gil/extension/toolbox/color_spaces/cmyka.hpp   (contents, props changed)
   trunk/boost/gil/extension/toolbox/color_spaces/gray_alpha.hpp   (contents, props changed)
   trunk/boost/gil/extension/toolbox/color_spaces/hsl.hpp   (contents, props changed)
   trunk/boost/gil/extension/toolbox/color_spaces/hsv.hpp   (contents, props changed)
   trunk/boost/gil/extension/toolbox/color_spaces/lab.hpp   (contents, props changed)
   trunk/boost/gil/extension/toolbox/color_spaces/xyz.hpp   (contents, props changed)
   trunk/boost/gil/extension/toolbox/dynamic_images.hpp   (contents, props changed)
   trunk/boost/gil/extension/toolbox/image_types/
   trunk/boost/gil/extension/toolbox/image_types.hpp   (contents, props changed)
   trunk/boost/gil/extension/toolbox/image_types/indexed_image.hpp   (contents, props changed)
   trunk/boost/gil/extension/toolbox/metafunctions/
   trunk/boost/gil/extension/toolbox/metafunctions.hpp   (contents, props changed)
   trunk/boost/gil/extension/toolbox/metafunctions/channel_type.hpp   (contents, props changed)
   trunk/boost/gil/extension/toolbox/metafunctions/channel_view.hpp   (contents, props changed)
   trunk/boost/gil/extension/toolbox/metafunctions/get_num_bits.hpp   (contents, props changed)
   trunk/boost/gil/extension/toolbox/metafunctions/get_pixel_type.hpp   (contents, props changed)
   trunk/boost/gil/extension/toolbox/metafunctions/gil_extensions.hpp   (contents, props changed)
   trunk/boost/gil/extension/toolbox/metafunctions/is_bit_aligned.hpp   (contents, props changed)
   trunk/boost/gil/extension/toolbox/metafunctions/is_homogeneous.hpp   (contents, props changed)
   trunk/boost/gil/extension/toolbox/metafunctions/is_similar.hpp   (contents, props changed)
   trunk/boost/gil/extension/toolbox/metafunctions/pixel_bit_size.hpp   (contents, props changed)
   trunk/boost/gil/extension/toolbox/toolbox.hpp   (contents, props changed)

Added: trunk/boost/gil/extension/toolbox/color_converters.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/gil/extension/toolbox/color_converters.hpp	2013-02-06 20:37:47 EST (Wed, 06 Feb 2013)
@@ -0,0 +1,25 @@
+/*
+    Copyright 2012 Christian Henning
+    Use, modification and distribution are subject to the Boost Software License,
+    Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt).
+*/
+
+/*************************************************************************************************/
+
+#ifndef BOOST_GIL_EXTENSION_TOOLBOX_COLOR_CONVERTERS_HPP
+#define BOOST_GIL_EXTENSION_TOOLBOX_COLOR_CONVERTERS_HPP
+
+////////////////////////////////////////////////////////////////////////////////////////
+/// \file color_converters.hpp
+/// \brief Color converters for toolbox extension.
+/// \author Christian Henning \n
+///
+/// \date 2012 \n
+///
+////////////////////////////////////////////////////////////////////////////////////////
+
+#include <boost/gil/extension/toolbox/color_converters/gray_to_rgba.hpp>
+#include <boost/gil/extension/toolbox/color_converters/rgb_to_luminance.hpp>
+
+#endif // BOOST_GIL_EXTENSION_TOOLBOX_COLOR_CONVERTERS_HPP

Added: trunk/boost/gil/extension/toolbox/color_converters/gray_to_rgba.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/gil/extension/toolbox/color_converters/gray_to_rgba.hpp	2013-02-06 20:37:47 EST (Wed, 06 Feb 2013)
@@ -0,0 +1,49 @@
+/*
+    Copyright 2012 Christian Henning, Andreas Pokorny, Lubomir Bourdev
+    Use, modification and distribution are subject to the Boost Software License,
+    Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt).
+*/
+
+/*************************************************************************************************/
+
+#ifndef BOOST_GIL_EXTENSION_TOOLBOX_COLOR_CONVERTERS_GRAY_TO_RGBA_HPP
+#define BOOST_GIL_EXTENSION_TOOLBOX_COLOR_CONVERTERS_GRAY_TO_RGBA_HPP
+
+////////////////////////////////////////////////////////////////////////////////////////
+/// \file
+/// \brief
+/// \author Christian Henning, Andreas Pokorny, Lubomir Bourdev \n
+///
+/// \date 2012 \n
+///
+////////////////////////////////////////////////////////////////////////////////////////
+
+#include <boost/gil/color_convert.hpp>
+
+namespace boost{ namespace gil {
+
+/// This one is missing in gil ( color_convert.hpp ).
+template <>
+struct default_color_converter_impl<gray_t,rgba_t>
+{
+    template <typename P1, typename P2>
+    void operator()(const P1& src, P2& dst) const
+    {
+        get_color(dst,red_t())  =
+            channel_convert<typename color_element_type<P2, red_t  >::type>(get_color(src,gray_color_t()));
+        get_color(dst,green_t())=
+            channel_convert<typename color_element_type<P2, green_t>::type>(get_color(src,gray_color_t()));
+        get_color(dst,blue_t()) =
+            channel_convert<typename color_element_type<P2, blue_t >::type>(get_color(src,gray_color_t()));
+
+        typedef typename channel_type< P2 >::type channel_t;
+        get_color(dst,alpha_t()) = channel_traits< channel_t >::max_value();
+    }
+};
+
+} // namespace gil
+} // namespace boost
+
+#endif // #define BOOST_GIL_EXTENSION_TOOLBOX_COLOR_CONVERTERS_GRAY_TO_RGBA_HPP
+

Added: trunk/boost/gil/extension/toolbox/color_converters/rgb_to_luminance.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/gil/extension/toolbox/color_converters/rgb_to_luminance.hpp	2013-02-06 20:37:47 EST (Wed, 06 Feb 2013)
@@ -0,0 +1,43 @@
+/*
+    Copyright 2012 Christian Henning, Andreas Pokorny, Lubomir Bourdev
+    Use, modification and distribution are subject to the Boost Software License,
+    Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt).
+*/
+
+/*************************************************************************************************/
+
+#ifndef BOOST_GIL_EXTENSION_TOOLBOX_COLOR_CONVERTERS_RGB_TO_LUMINANCE_HPP
+#define BOOST_GIL_EXTENSION_TOOLBOX_COLOR_CONVERTERS_RGB_TO_LUMINANCE_HPP
+
+////////////////////////////////////////////////////////////////////////////////////////
+/// \file
+/// \brief
+/// \author Christian Henning, Andreas Pokorny, Lubomir Bourdev \n
+///
+/// \date 2012 \n
+///
+////////////////////////////////////////////////////////////////////////////////////////
+
+#include <boost/gil/color_convert.hpp>
+
+namespace boost{ namespace gil { namespace detail {
+
+/// - performance specialization double
+/// - to eliminate compiler warning 4244
+template <typename GrayChannelValue>
+struct rgb_to_luminance_fn< double, double, double, GrayChannelValue >
+{
+    GrayChannelValue operator()( const double& red
+                               , const double& green
+                               , const double& blue    ) const
+   {
+      return channel_convert<GrayChannelValue>( red * 0.30 + green * 0.59 + blue * 0.11 );
+   }
+};
+
+} // namespace detail
+} // namespace gil
+} // namespace boost
+
+#endif // #define BOOST_GIL_EXTENSION_TOOLBOX_COLOR_CONVERTERS_RGB_TO_LUMINANCE_HPP

Added: trunk/boost/gil/extension/toolbox/color_spaces.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/gil/extension/toolbox/color_spaces.hpp	2013-02-06 20:37:47 EST (Wed, 06 Feb 2013)
@@ -0,0 +1,29 @@
+/*
+    Copyright 2012 Christian Henning
+    Use, modification and distribution are subject to the Boost Software License,
+    Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt).
+*/
+
+/*************************************************************************************************/
+
+#ifndef BOOST_GIL_EXTENSION_TOOLBOX_COLOR_SPACES_HPP
+#define BOOST_GIL_EXTENSION_TOOLBOX_COLOR_SPACES_HPP
+
+////////////////////////////////////////////////////////////////////////////////////////
+/// \file color_spaces.hpp
+/// \brief Color spaces for toolbox extension.
+/// \author Christian Henning \n
+///
+/// \date 2012 \n
+///
+////////////////////////////////////////////////////////////////////////////////////////
+
+#include <boost/gil/extension/toolbox/color_spaces/cmyka.hpp>
+#include <boost/gil/extension/toolbox/color_spaces/gray_alpha.hpp>
+#include <boost/gil/extension/toolbox/color_spaces/hsl.hpp>
+#include <boost/gil/extension/toolbox/color_spaces/hsv.hpp>
+#include <boost/gil/extension/toolbox/color_spaces/lab.hpp>
+#include <boost/gil/extension/toolbox/color_spaces/xyz.hpp>
+
+#endif // BOOST_GIL_EXTENSION_TOOLBOX_COLOR_SPACES_HPP

Added: trunk/boost/gil/extension/toolbox/color_spaces/cmyka.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/gil/extension/toolbox/color_spaces/cmyka.hpp	2013-02-06 20:37:47 EST (Wed, 06 Feb 2013)
@@ -0,0 +1,87 @@
+/*
+    Copyright 2012 Christian Henning
+    Use, modification and distribution are subject to the Boost Software License,
+    Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt).
+*/
+
+/*************************************************************************************************/
+
+#ifndef BOOST_GIL_EXTENSION_TOOLBOX_COLOR_SPACES_CMYKA_HPP
+#define BOOST_GIL_EXTENSION_TOOLBOX_COLOR_SPACES_CMYKA_HPP
+
+////////////////////////////////////////////////////////////////////////////////////////
+/// \file cmyka.hpp
+/// \brief Support for cmyka color space.
+/// \author Christian Henning \n
+///
+/// \date 2012 \n
+///
+////////////////////////////////////////////////////////////////////////////////////////
+
+#include <boost\gil\rgba.hpp>
+#include <boost\gil\cmyk.hpp>
+
+#include <boost\gil\color_convert.hpp>
+#include <boost\gil\typedefs.hpp>
+
+namespace boost{ namespace gil {
+
+/// \ingroup ColorSpaceModel
+typedef mpl::vector5<cyan_t,magenta_t,yellow_t,black_t,alpha_t> cmyka_t;
+
+/// \ingroup LayoutModel
+typedef layout<cmyka_t> cmyka_layout_t;
+
+
+GIL_DEFINE_ALL_TYPEDEFS(8,  cmyka)
+GIL_DEFINE_ALL_TYPEDEFS(8s, cmyka)
+GIL_DEFINE_ALL_TYPEDEFS(16, cmyka)
+GIL_DEFINE_ALL_TYPEDEFS(16s,cmyka)
+GIL_DEFINE_ALL_TYPEDEFS(32 ,cmyka)
+GIL_DEFINE_ALL_TYPEDEFS(32s,cmyka)
+GIL_DEFINE_ALL_TYPEDEFS(32f,cmyka)
+
+///// \ingroup ColorConvert
+///// \brief Converting CMYKA to any pixel type. Note: Supports homogeneous pixels only.
+//template <typename C2>
+//struct default_color_converter_impl<cmyka_t,C2> {
+//    template <typename P1, typename P2>
+//    void operator()(const P1& src, P2& dst) const {
+//        typedef typename channel_type<P1>::type T1;
+//        default_color_converter_impl<cmyk_t,C2>()(
+//            pixel<T1,cmyk_layout_t>(channel_multiply(get_color(src,cyan_t()),  get_color(src,alpha_t())), 
+//                                    channel_multiply(get_color(src,magenta_t()),get_color(src,alpha_t())), 
+//                                    channel_multiply(get_color(src,yellow_t()), get_color(src,alpha_t())),
+//									channel_multiply(get_color(src,black_t()), get_color(src,alpha_t())))
+//            ,dst);
+//    }
+//};
+template <>
+struct default_color_converter_impl<cmyka_t,rgba_t> {
+    template <typename P1, typename P2>
+    void operator()(const P1& src, P2& dst) const {
+        typedef typename channel_type<P1>::type T1;
+        default_color_converter_impl<cmyk_t,rgba_t>()(
+            pixel<T1,cmyk_layout_t>(get_color(src,cyan_t()), 
+                                    get_color(src,magenta_t()), 
+                                    get_color(src,yellow_t()),
+									get_color(src,black_t()))
+            ,dst);
+    }
+};
+
+/// \ingroup ColorConvert
+/// \brief Unfortunately CMYKA to CMYKA must be explicitly provided - otherwise we get ambiguous specialization error.
+template <>
+struct default_color_converter_impl<cmyka_t,cmyka_t> {
+    template <typename P1, typename P2>
+    void operator()(const P1& src, P2& dst) const {
+        static_for_each(src,dst,default_channel_converter());
+    }
+};
+
+} // namespace gil
+} // namespace boost
+
+#endif // BOOST_GIL_EXTENSION_TOOLBOX_COLOR_SPACES_CMYKA_HPP

Added: trunk/boost/gil/extension/toolbox/color_spaces/gray_alpha.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/gil/extension/toolbox/color_spaces/gray_alpha.hpp	2013-02-06 20:37:47 EST (Wed, 06 Feb 2013)
@@ -0,0 +1,104 @@
+/*
+    Copyright 2012 Andreas Pokorny
+    Use, modification and distribution are subject to the Boost Software License,
+    Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt).
+*/
+
+/*************************************************************************************************/
+
+#ifndef BOOST_GIL_EXTENSION_TOOLBOX_COLOR_SPACES_GRAY_ALPHA_HPP
+#define BOOST_GIL_EXTENSION_TOOLBOX_COLOR_SPACES_GRAY_ALPHA_HPP
+
+////////////////////////////////////////////////////////////////////////////////////////
+/// \file gray_alpha.hpp
+/// \brief Support for gray_alpha color space.
+/// \author Andreas Pokorny \n
+///
+/// \date 2012 \n
+///
+////////////////////////////////////////////////////////////////////////////////////////
+
+#include <boost/mpl/contains.hpp>
+
+#include <boost/gil/gil_config.hpp>
+#include <boost/gil/color_convert.hpp>
+#include <boost/gil/gray.hpp>
+#include <boost/gil/typedefs.hpp>
+
+namespace boost{ namespace gil {
+
+typedef mpl::vector2<gray_color_t,alpha_t> gray_alpha_t;
+
+typedef layout<gray_alpha_t> gray_alpha_layout_t;
+typedef layout<gray_alpha_layout_t, mpl::vector2_c<int,1,0> > alpha_gray_layout_t;
+
+GIL_DEFINE_BASE_TYPEDEFS(8,  alpha_gray)
+GIL_DEFINE_BASE_TYPEDEFS(8s, alpha_gray)
+GIL_DEFINE_BASE_TYPEDEFS(16, alpha_gray)
+GIL_DEFINE_BASE_TYPEDEFS(16s,alpha_gray)
+GIL_DEFINE_BASE_TYPEDEFS(32 ,alpha_gray)
+GIL_DEFINE_BASE_TYPEDEFS(32s,alpha_gray)
+GIL_DEFINE_BASE_TYPEDEFS(32f,alpha_gray)
+
+GIL_DEFINE_ALL_TYPEDEFS(8,  gray_alpha)
+GIL_DEFINE_ALL_TYPEDEFS(8s, gray_alpha)
+GIL_DEFINE_ALL_TYPEDEFS(16, gray_alpha)
+GIL_DEFINE_ALL_TYPEDEFS(16s,gray_alpha)
+GIL_DEFINE_ALL_TYPEDEFS(32 ,gray_alpha)
+GIL_DEFINE_ALL_TYPEDEFS(32s,gray_alpha)
+GIL_DEFINE_ALL_TYPEDEFS(32f,gray_alpha)
+
+/// \ingroup ColorConvert
+/// \brief Gray Alpha to RGBA
+template <>
+struct default_color_converter_impl<gray_alpha_t,rgba_t> {
+    template <typename P1, typename P2>
+    void operator()(const P1& src, P2& dst) const {
+        get_color(dst,red_t())  =
+            channel_convert<typename color_element_type<P2, red_t>::type>(get_color(src,gray_color_t()));
+        get_color(dst,green_t())=
+            channel_convert<typename color_element_type<P2, green_t>::type>(get_color(src,gray_color_t()));
+        get_color(dst,blue_t()) =
+            channel_convert<typename color_element_type<P2, blue_t>::type>(get_color(src,gray_color_t()));
+        get_color(dst,alpha_t()) =
+            channel_convert<typename color_element_type<P2, alpha_t>::type>(get_color(src,alpha_t()));
+    }
+};
+
+/// \brief Gray Alpha to RGB
+template <>
+struct default_color_converter_impl<gray_alpha_t,rgb_t> {
+    template <typename P1, typename P2>
+    void operator()(const P1& src, P2& dst) const {
+        get_color(dst,red_t())  =
+            channel_convert<typename color_element_type<P2, red_t>::type>(
+                channel_multiply(get_color(src,gray_color_t()),get_color(src,alpha_t()) ) 
+                );
+        get_color(dst,green_t())  =
+            channel_convert<typename color_element_type<P2, green_t>::type>(
+                channel_multiply(get_color(src,gray_color_t()),get_color(src,alpha_t()) ) 
+                );
+        get_color(dst,blue_t())  =
+            channel_convert<typename color_element_type<P2, blue_t>::type>(
+                channel_multiply(get_color(src,gray_color_t()),get_color(src,alpha_t()) ) 
+                );
+    }
+};
+
+/// \brief Gray Alpha to Gray
+template <>
+struct default_color_converter_impl<gray_alpha_t,gray_t> {
+    template <typename P1, typename P2>
+    void operator()(const P1& src, P2& dst) const {
+        get_color(dst,gray_color_t())  =
+            channel_convert<typename color_element_type<P2, gray_color_t>::type>(
+                channel_multiply(get_color(src,gray_color_t()),get_color(src,alpha_t()) ) 
+                );
+    }
+};
+
+} // namespace gil
+} // namespace boost
+
+#endif // BOOST_GIL_EXTENSION_TOOLBOX_COLOR_SPACES_GRAY_ALPHA_HPP

Added: trunk/boost/gil/extension/toolbox/color_spaces/hsl.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/gil/extension/toolbox/color_spaces/hsl.hpp	2013-02-06 20:37:47 EST (Wed, 06 Feb 2013)
@@ -0,0 +1,266 @@
+/*
+    Copyright 2012 Christian Henning
+    Use, modification and distribution are subject to the Boost Software License,
+    Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt).
+*/
+
+/*************************************************************************************************/
+
+#ifndef BOOST_GIL_EXTENSION_TOOLBOX_COLOR_SPACES_HSL_HPP
+#define BOOST_GIL_EXTENSION_TOOLBOX_COLOR_SPACES_HSL_HPP
+
+////////////////////////////////////////////////////////////////////////////////////////
+/// \file hsl.hpp
+/// \brief Support for HSL color space
+/// \author Christian Henning \n
+///
+/// \date 2012 \n
+///
+////////////////////////////////////////////////////////////////////////////////////////
+
+namespace boost{ namespace gil {
+
+/// \addtogroup ColorNameModel
+/// \{
+namespace hsl_color_space
+{
+/// \brief Hue
+struct hue_t {};    
+/// \brief Saturation
+struct saturation_t {};
+/// \brief Lightness
+struct lightness_t {}; 
+}
+/// \}
+
+/// \ingroup ColorSpaceModel
+typedef mpl::vector3< hsl_color_space::hue_t
+                    , hsl_color_space::saturation_t
+                    , hsl_color_space::lightness_t
+                    > hsl_t;
+
+/// \ingroup LayoutModel
+typedef layout<hsl_t> hsl_layout_t;
+
+
+GIL_DEFINE_ALL_TYPEDEFS( 32f, hsl );
+
+/// \ingroup ColorConvert
+/// \brief RGB to HSL
+template <>
+struct default_color_converter_impl< rgb_t, hsl_t >
+{
+   template <typename P1, typename P2>
+   void operator()( const P1& src, P2& dst ) const
+   {
+      using namespace hsl_color_space;
+
+      // only bits32f for hsl is supported
+      bits32f temp_red   = channel_convert<bits32f>( get_color( src, red_t()   ));
+      bits32f temp_green = channel_convert<bits32f>( get_color( src, green_t() ));
+      bits32f temp_blue  = channel_convert<bits32f>( get_color( src, blue_t()  ));
+
+      bits32f hue, saturation, lightness;
+
+      bits32f min_color = (std::min)( temp_red, (std::min)( temp_green, temp_blue ));
+      bits32f max_color = (std::max)( temp_red, (std::max)( temp_green, temp_blue ));
+
+      if( abs( min_color - max_color ) < 0.001 )
+      {
+         // rgb color is gray
+
+         hue        = 0.f;
+         saturation = 0.f;
+
+         // doesn't matter which rgb channel we use.
+         lightness = temp_red;
+      }
+      else
+      {
+
+         bits32f diff = max_color - min_color;
+
+         // lightness calculation
+
+         lightness = ( min_color + max_color ) / 2.f;
+
+         // saturation calculation
+
+         if( lightness < 0.5f )
+         {
+            saturation = diff 
+                       / ( min_color + max_color );
+         }
+         else
+         {
+            saturation = ( max_color - min_color ) 
+                       / ( 2.f - diff );
+
+         }
+
+         // hue calculation
+         if( abs( max_color - temp_red ) < 0.0001f )
+         {
+            // max_color is red
+            hue = ( temp_green - temp_blue ) 
+                / diff;
+
+         }
+         else if( abs( max_color - temp_green) < 0.0001f )
+         {
+            // max_color is green
+            // 2.0 + (b - r) / (maxColor - minColor);
+            hue = 2.f 
+                + ( temp_blue - temp_red ) 
+                / diff;
+
+         }
+         else
+         {
+            // max_color is blue
+            hue = 4.f 
+                + ( temp_red - temp_blue ) 
+                / diff;
+         }
+
+         hue /= 6.f;
+         
+         if( hue < 0.f )
+         {
+            hue += 1.f;
+         }
+      }
+
+      get_color( dst,hue_t() )        = hue;
+      get_color( dst,saturation_t() ) = saturation;
+      get_color( dst,lightness_t() )  = lightness;
+   }
+};
+
+/// \ingroup ColorConvert
+/// \brief HSL to RGB
+template <>
+struct default_color_converter_impl<hsl_t,rgb_t>
+{
+   template <typename P1, typename P2>
+   void operator()( const P1& src, P2& dst) const
+   {
+      using namespace hsl_color_space;
+
+      bits32f red, green, blue;
+
+      if( abs( get_color( src, saturation_t() )) < 0.0001  )
+      {
+         // If saturation is 0, the color is a shade of gray
+         red   = get_color( src, lightness_t() );
+         green = get_color( src, lightness_t() );
+         blue  = get_color( src, lightness_t() );
+      }
+      else
+      {
+         float temp1, temp2;
+         float tempr, tempg, tempb;
+
+         //Set the temporary values
+         if( get_color( src, lightness_t() ) < 0.5 ) 
+         {
+            temp2 = get_color( src, lightness_t() )
+                  * ( 1.f + get_color( src, saturation_t() ) );
+         }
+         else
+         {
+            temp2 = ( get_color( src, lightness_t() ) + get_color( src, saturation_t() )) 
+                  - ( get_color( src, lightness_t() ) * get_color( src, saturation_t() ));
+         }
+
+         temp1 = 2.f
+               * get_color( src, lightness_t() ) 
+               - temp2;
+
+         tempr = get_color( src, hue_t() ) + 1.f / 3.f;    
+
+         if( tempr > 1.f )
+         {
+            tempr--;
+         }
+
+         tempg = get_color( src, hue_t() );     
+         tempb = get_color( src, hue_t() ) - 1.f / 3.f;
+
+         if( tempb < 0.f )
+         {
+            tempb++;
+         }
+
+         //Red     
+         if( tempr < 1.f / 6.f )
+         {
+            red = temp1 + ( temp2 - temp1 ) * 6.f * tempr;
+         }
+         else if( tempr < 0.5f )
+         {
+            red = temp2;
+         }
+         else if( tempr < 2.f / 3.f )
+         {
+            red = temp1 + (temp2 - temp1) 
+                * (( 2.f / 3.f ) - tempr) * 6.f;
+         }
+         else
+         {
+            red = temp1;
+         }
+
+         //Green       
+         if( tempg < 1.f / 6.f )
+         {
+            green = temp1 + ( temp2 - temp1 ) * 6.f * tempg;
+         }
+         else if( tempg < 0.5f )
+         {
+            green = temp2;
+         }
+         else if( tempg < 2.f / 3.f )
+         {
+            green = temp1 + ( temp2 - temp1 )
+                  * (( 2.f / 3.f ) - tempg) * 6.f;
+         }
+         else
+         {
+            green = temp1;
+         }
+
+         //Blue    
+         if( tempb < 1.f / 6.f )
+         {
+            blue = temp1 + (temp2 - temp1) * 6.f * tempb;
+         }
+         else if( tempb < 0.5f )
+         {
+            blue = temp2;
+         }
+         else if( tempb < 2.f / 3.f )
+         {
+            blue = temp1 + (temp2 - temp1) 
+                 * (( 2.f / 3.f ) - tempb) * 6.f;
+         }
+         else
+         {
+            blue = temp1;
+         }
+      }
+
+      get_color(dst,red_t())  =
+         channel_convert<typename color_element_type< P2, red_t >::type>( red );
+      get_color(dst,green_t())=
+         channel_convert<typename color_element_type< P2, green_t >::type>( green );
+      get_color(dst,blue_t()) =
+         channel_convert<typename color_element_type< P2, blue_t >::type>( blue );
+   }
+};
+
+} // namespace gil
+} // namespace boost
+
+#endif // BOOST_GIL_EXTENSION_TOOLBOX_COLOR_SPACES_HSL_HPP

Added: trunk/boost/gil/extension/toolbox/color_spaces/hsv.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/gil/extension/toolbox/color_spaces/hsv.hpp	2013-02-06 20:37:47 EST (Wed, 06 Feb 2013)
@@ -0,0 +1,235 @@
+/*
+    Copyright 2012 Christian Henning
+    Use, modification and distribution are subject to the Boost Software License,
+    Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt).
+*/
+
+/*************************************************************************************************/
+
+#ifndef BOOST_GIL_EXTENSION_TOOLBOX_COLOR_SPACES_HSV_HPP
+#define BOOST_GIL_EXTENSION_TOOLBOX_COLOR_SPACES_HSV_HPP
+
+////////////////////////////////////////////////////////////////////////////////////////
+/// \file hsv.hpp
+/// \brief Support for HSV color space
+/// \author Christian Henning \n
+///
+/// \date 2012 \n
+///
+////////////////////////////////////////////////////////////////////////////////////////
+
+#include <boost/cast.hpp>
+
+namespace boost{ namespace gil {
+
+/// \addtogroup ColorNameModel
+/// \{
+namespace hsv_color_space
+{
+/// \brief Hue
+struct hue_t {};    
+/// \brief Saturation
+struct saturation_t{};
+/// \brief Value
+struct value_t {}; 
+}
+/// \}
+
+/// \ingroup ColorSpaceModel
+typedef mpl::vector3< hsv_color_space::hue_t
+                    , hsv_color_space::saturation_t
+                    , hsv_color_space::value_t
+                    > hsv_t;
+
+/// \ingroup LayoutModel
+typedef layout<hsv_t> hsv_layout_t;
+
+GIL_DEFINE_ALL_TYPEDEFS( 32f, hsv )
+
+/// \ingroup ColorConvert
+/// \brief RGB to HSV
+template <>
+struct default_color_converter_impl< rgb_t, hsv_t >
+{
+   template <typename P1, typename P2>
+   void operator()( const P1& src, P2& dst ) const
+   {
+      using namespace hsv_color_space;
+
+      // only bits32f for hsv is supported
+      bits32f temp_red   = channel_convert<bits32f>( get_color( src, red_t()   ));
+      bits32f temp_green = channel_convert<bits32f>( get_color( src, green_t() ));
+      bits32f temp_blue  = channel_convert<bits32f>( get_color( src, blue_t()  ));
+
+      bits32f hue, saturation, value;
+
+      bits32f min_color = (std::min)( temp_red, (std::min)( temp_green, temp_blue ));
+      bits32f max_color = (std::max)( temp_red, (std::max)( temp_green, temp_blue ));
+
+      value = max_color;
+
+      bits32f diff = max_color - min_color;
+
+      if( max_color < 0.0001f )
+      {  
+         saturation = 0.f;
+      }
+      else  
+      {      
+         saturation = diff / max_color;
+      }
+
+
+      if( saturation < 0.0001f )
+      {
+         //it doesn't matter what value it has
+         hue = 0.f; 
+      }   
+      else
+      { 
+         if( (std::abs)( boost::numeric_cast<int>(temp_red - max_color) ) < 0.0001f )
+         {
+            hue = ( temp_green - temp_blue )
+                / diff;
+         }
+         else if( temp_green == max_color )
+         {
+            hue = 2.f + ( temp_blue - temp_red ) 
+                / diff;
+         }
+         else
+         {
+            hue = 4.f + ( temp_red - temp_green ) 
+                / diff;
+         }
+
+         //to bring it to a number between 0 and 1
+         hue /= 6.f; 
+
+         if( hue < 0.f )
+         {
+            hue++;
+         }
+      }
+
+      get_color( dst, hue_t() )        = hue;
+      get_color( dst, saturation_t() ) = saturation;
+      get_color( dst, value_t() )      = value;
+   }
+};
+
+/// \ingroup ColorConvert
+/// \brief HSV to RGB
+template <>
+struct default_color_converter_impl<hsv_t,rgb_t>
+{
+   template <typename P1, typename P2>
+   void operator()( const P1& src, P2& dst) const
+   {
+      using namespace hsv_color_space;
+
+      bits32f red, green, blue;
+
+      //If saturation is 0, the color is a shade of gray
+      if( abs( get_color( src, saturation_t() )) < 0.0001f  )
+      {
+         // If saturation is 0, the color is a shade of gray
+         red   = get_color( src, value_t() );
+         green = get_color( src, value_t() );
+         blue  = get_color( src, value_t() );
+      }
+      else
+      {
+         bits32f frac, p, q, t, h;
+         bits32 i;
+
+         //to bring hue to a number between 0 and 6, better for the calculations
+         h = get_color( src, hue_t() );
+         h *= 6.f;
+
+         i = static_cast<bits32>( floor( h ));
+
+         frac = h - i;
+
+         p = get_color( src, value_t() ) 
+           * ( 1.f - get_color( src, saturation_t() ));
+
+         q = get_color( src, value_t() )
+           * ( 1.f - ( get_color( src, saturation_t() ) * frac ));
+
+         t = get_color( src, value_t() ) 
+           * ( 1.f - ( get_color( src, saturation_t() ) * ( 1.f - frac )));
+
+         switch( i )
+         {         
+            case 0: 
+            {
+               red   = get_color( src, value_t() );
+               green = t;
+               blue  = p;
+
+               break;
+            }
+
+            case 1: 
+            {
+               red   = q;
+               green = get_color( src, value_t() );
+               blue  = p;
+
+               break;
+            }
+
+            case 2: 
+            {
+               red   = p;
+               green = get_color( src, value_t() );
+               blue  = t;
+
+               break;
+            }
+
+            case 3: 
+            {
+               red   = p;
+               green = q;
+               blue  = get_color( src, value_t() );
+
+               break;
+            }
+
+            case 4: 
+            {
+               red   = t;
+               green = p;
+               blue  = get_color( src, value_t() );
+
+               break;
+            }
+
+            case 5: 
+            {
+               red   = get_color( src, value_t() );
+               green = p; 
+               blue  = q;
+
+               break;
+            }
+
+         }
+      }
+
+      get_color(dst,red_t())  =
+         channel_convert<typename color_element_type< P2, red_t >::type>( red );
+      get_color(dst,green_t())=
+         channel_convert<typename color_element_type< P2, green_t >::type>( green );
+      get_color(dst,blue_t()) =
+         channel_convert<typename color_element_type< P2, blue_t >::type>( blue );
+   }
+};
+
+} // namespace gil
+} // namespace boost
+
+#endif // BOOST_GIL_EXTENSION_TOOLBOX_COLOR_SPACES_HSV_HPP

Added: trunk/boost/gil/extension/toolbox/color_spaces/lab.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/gil/extension/toolbox/color_spaces/lab.hpp	2013-02-06 20:37:47 EST (Wed, 06 Feb 2013)
@@ -0,0 +1,179 @@
+/*
+    Copyright 2012 Chung-Lin Wen
+    Use, modification and distribution are subject to the Boost Software License,
+    Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt).
+*/
+
+/*************************************************************************************************/
+
+#ifndef BOOST_GIL_EXTENSION_TOOLBOX_COLOR_SPACES_LAB_HPP
+#define BOOST_GIL_EXTENSION_TOOLBOX_COLOR_SPACES_LAB_HPP
+
+////////////////////////////////////////////////////////////////////////////////////////
+/// \file lab.hpp
+/// \brief Support for CIE Lab color space
+/// \author Chung-Lin Wen \n
+///
+/// \date 2012 \n
+///
+////////////////////////////////////////////////////////////////////////////////////////
+
+#include <boost/cast.hpp>
+#include <boost/gil/gil_all.hpp>
+#include <boost/gil/extension/toolbox/color_spaces/xyz.hpp>
+
+namespace boost{ namespace gil {
+
+/// \addtogroup ColorNameModel
+/// \{
+namespace lab_color_space
+{
+/// \brief Luminance
+struct luminance_t {};    
+/// \brief a Color Component
+struct a_color_opponent_t {};
+/// \brief b Color Component
+struct b_color_opponent_t {}; 
+}
+/// \}
+
+/// \ingroup ColorSpaceModel
+typedef mpl::vector3< lab_color_space::luminance_t
+                    , lab_color_space::a_color_opponent_t
+                    , lab_color_space::b_color_opponent_t
+                    > lab_t;
+
+/// \ingroup LayoutModel
+typedef layout<lab_t> lab_layout_t;
+
+GIL_DEFINE_ALL_TYPEDEFS( 32f, lab );
+
+/// \ingroup ColorConvert
+/// \brief LAB to XYZ
+template <>
+struct default_color_converter_impl< lab_t, xyz_t >
+{
+    template <typename P1, typename P2>
+    void operator()( const P1& src, P2& dst ) const
+    {
+        using namespace lab_color_space;
+        using namespace xyz_color_space;
+
+        bits32f p = ((get_color(src, luminance_t()) + 16.f)/116.f);
+
+        get_color(dst, y_t()) =
+                1.f * powf(p, 3.f);
+
+        get_color(dst, x_t()) =
+                0.95047f * powf((p +
+                                 (get_color(src, a_color_opponent_t())/500.f)
+                                 ), 3.f);
+        get_color(dst, z_t()) =
+                1.08883f * powf((p -
+                                 (get_color(src, b_color_opponent_t())/200.f)
+                                 ), 3.f);
+    }
+};
+
+/// \ingroup ColorConvert
+/// \brief XYZ to LAB
+/// \note I assume \c xyz_t
+template <>
+struct default_color_converter_impl< xyz_t, lab_t >
+{
+private:
+    /// \ref http://www.brucelindbloom.com/index.html?Eqn_XYZ_to_Lab.html
+    GIL_FORCEINLINE
+    bits32f forward_companding(bits32f value) const
+    {
+        if (value > 216.f/24389.f)
+        {
+            return powf(value, 1.f/3.f);
+        }
+        else
+        {
+            return ((24389.f/27.f * value + 16.f)/116.f);
+        }
+    }
+
+public:
+    template <typename P1, typename P2>
+    void operator()( const P1& src, P2& dst ) const
+    {
+        using namespace lab_color_space;
+
+        bits32f f_y =
+                forward_companding(
+                    channel_convert<bits32f>(
+                        get_color(src, xyz_color_space::y_t())
+                        )
+                    // / 1.f
+                    );
+
+        bits32f f_x =
+                forward_companding(
+                    channel_convert<bits32f>(
+                        get_color(src, xyz_color_space::x_t())
+                        )
+                    * (1.f / 0.95047f)  // if the compiler is smart, it should
+                                        // precalculate this, no?
+                    );
+
+        bits32f f_z =
+                forward_companding(
+                    channel_convert<bits32f>(
+                        get_color(src, xyz_color_space::z_t())
+                        )
+                    * (1.f / 1.08883f)  // if the compiler is smart, it should
+                                        // precalculate this, no?
+                    );
+
+        get_color(dst, luminance_t()) =
+                116.f * f_y - 16.f;
+
+        get_color(dst, a_color_opponent_t()) =
+                500.f * (f_x - f_y);
+
+        get_color(dst, b_color_opponent_t()) =
+                200.f * (f_y - f_z);
+    }
+};
+
+
+/// \ingroup ColorConvert
+/// \brief RGB to LAB
+template <>
+struct default_color_converter_impl< rgb_t, lab_t >
+{
+    template <typename P1, typename P2>
+    void operator()( const P1& src, P2& dst ) const
+    {
+        using namespace lab_color_space;
+
+        xyz32f_pixel_t xyz32f_temp_pixel;
+        default_color_converter_impl<rgb_t, xyz_t>()(src, xyz32f_temp_pixel);
+        default_color_converter_impl<xyz_t, lab_t>()(xyz32f_temp_pixel, dst);
+    }
+};
+
+/// \ingroup ColorConvert
+/// \brief LAB to RGB
+template <>
+struct default_color_converter_impl<lab_t,rgb_t>
+{
+    template <typename P1, typename P2>
+    void operator()( const P1& src, P2& dst) const
+    {
+        using namespace lab_color_space;
+
+        xyz32f_pixel_t xyz32f_temp_pixel;
+        default_color_converter_impl<lab_t, xyz_t>()(src, xyz32f_temp_pixel);
+        default_color_converter_impl<xyz_t, rgb_t>()(xyz32f_temp_pixel, dst);
+    }
+};
+
+} // namespace gil
+} // namespace boost
+
+#endif // BOOST_GIL_EXTENSION_TOOLBOX_COLOR_SPACES_LAB_HPP

Added: trunk/boost/gil/extension/toolbox/color_spaces/xyz.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/gil/extension/toolbox/color_spaces/xyz.hpp	2013-02-06 20:37:47 EST (Wed, 06 Feb 2013)
@@ -0,0 +1,163 @@
+/*
+    Copyright 2012 Chung-Lin Wen, Davide Anastasia
+    Use, modification and distribution are subject to the Boost Software License,
+    Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt).
+*/
+
+/*************************************************************************************************/
+
+#ifndef BOOST_GIL_EXTENSION_TOOLBOX_COLOR_SPACES_XYZ_HPP
+#define BOOST_GIL_EXTENSION_TOOLBOX_COLOR_SPACES_XYZ_HPP
+
+////////////////////////////////////////////////////////////////////////////////////////
+/// \file xyz.hpp
+/// \brief Support for CIE XYZ color space
+/// \author Chung-Lin Wen, Davide Anastasia \n
+///
+/// \date 2012 \n
+///
+////////////////////////////////////////////////////////////////////////////////////////
+
+#include <boost/cast.hpp>
+
+namespace boost{ namespace gil {
+
+/// \addtogroup ColorNameModel
+/// \{
+namespace xyz_color_space
+{
+/// \brief x Color Component
+struct x_t {};    
+/// \brief y Color Component
+struct y_t {};
+/// \brief z Color Component
+struct z_t {}; 
+}
+/// \}
+
+/// \ingroup ColorSpaceModel
+typedef mpl::vector3< xyz_color_space::x_t
+                    , xyz_color_space::y_t
+                    , xyz_color_space::z_t
+                    > xyz_t;
+
+/// \ingroup LayoutModel
+typedef layout<xyz_t> xyz_layout_t;
+
+GIL_DEFINE_ALL_TYPEDEFS( 32f, xyz );
+
+/// \ingroup ColorConvert
+/// \brief RGB to XYZ
+/// Link 
+/// \note rgb_t is assumed to be sRGB D65
+template <>
+struct default_color_converter_impl< rgb_t, xyz_t >
+{
+private:
+    GIL_FORCEINLINE
+    bits32f inverse_companding(bits32f sample) const
+    {
+        if ( sample > 0.04045f )
+        {
+            return powf((( sample + 0.055f ) / 1.055f ), 2.4f);
+        }
+        else
+        {
+            return ( sample / 12.92f );
+        }
+    }
+
+public:
+    template <typename P1, typename P2>
+    void operator()( const P1& src, P2& dst ) const
+    {
+        using namespace xyz_color_space;
+
+        bits32f red(
+                    inverse_companding(
+                        channel_convert<bits32f>( get_color( src, red_t() ))
+                        )
+                    );
+        bits32f green(
+                    inverse_companding(
+                        channel_convert<bits32f>( get_color( src, green_t() ))
+                        )
+                    );
+        bits32f blue(
+                    inverse_companding(
+                        channel_convert<bits32f>( get_color( src, blue_t() ))
+                        )
+                    );
+
+        get_color( dst, x_t() ) =
+                red * 0.4124564f +
+                green * 0.3575761f +
+                blue * 0.1804375f;
+        get_color( dst, y_t() ) =
+                red * 0.2126729f +
+                green * 0.7151522f +
+                blue * 0.0721750f;
+        get_color( dst, z_t() ) =
+                red * 0.0193339f +
+                green * 0.1191920f +
+                blue * 0.9503041f;
+    }
+};
+
+/// \ingroup ColorConvert
+/// \brief XYZ to RGB
+template <>
+struct default_color_converter_impl<xyz_t,rgb_t>
+{
+private:
+    GIL_FORCEINLINE
+    bits32f companding(bits32f sample) const
+    {
+        if ( sample > 0.0031308f )
+        {
+            return ( 1.055f * powf( sample, 1.f/2.4f ) - 0.055f );
+        }
+        else
+        {
+            return ( 12.92f * sample );
+        }
+    }
+
+public:
+    template <typename P1, typename P2>
+    void operator()( const P1& src, P2& dst) const
+    {
+        using namespace xyz_color_space;
+
+        // Note: ideally channel_convert should be compiled out, because xyz_t
+        // is bits32f natively only
+        bits32f x( channel_convert<bits32f>( get_color( src, x_t() ) ) );
+        bits32f y( channel_convert<bits32f>( get_color( src, y_t() ) ) );
+        bits32f z( channel_convert<bits32f>( get_color( src, z_t() ) ) );
+
+        get_color(dst,red_t())  =
+                channel_convert<typename color_element_type<P2, red_t>::type>(
+                    companding( x *  3.2404542f +
+                                y * -1.5371385f +
+                                z * -0.4985314f )
+                    );
+        get_color(dst,green_t()) =
+                channel_convert<typename color_element_type<P2, green_t>::type>(
+                    companding( x * -0.9692660f +
+                                y *  1.8760108f +
+                                z *  0.0415560f )
+                    );
+        get_color(dst,blue_t()) =
+                channel_convert<typename color_element_type<P2, blue_t>::type>(
+                    companding( x *  0.0556434f +
+                                y * -0.2040259f +
+                                z *  1.0572252f )
+                    );
+    }
+};
+
+} // namespace gil
+} // namespace boost
+
+#endif // BOOST_GIL_EXTENSION_TOOLBOX_COLOR_SPACES_XYZ_HPP

Added: trunk/boost/gil/extension/toolbox/dynamic_images.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/gil/extension/toolbox/dynamic_images.hpp	2013-02-06 20:37:47 EST (Wed, 06 Feb 2013)
@@ -0,0 +1,126 @@
+/*
+    Copyright 2005-2007 Adobe Systems Incorporated
+
+    Use, modification and distribution are subject to the Boost Software License,
+    Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt).
+
+    See http://opensource.adobe.com/gil for most recent version including documentation.
+*/
+/*************************************************************************************************/
+
+#ifndef BOOST_GIL_EXTENSION_TOOLBOX_DYNAMIC_IMAGES_HPP
+#define BOOST_GIL_EXTENSION_TOOLBOX_DYNAMIC_IMAGES_HPP
+
+////////////////////////////////////////////////////////////////////////////////////////
+/// \file dynamic_images.hpp
+/// \brief Generic io functions for dealing with dynamic images.
+/// \author Hailin Jin, Lubomir Bourdev, and Christian Henning \n
+///
+/// \date 2012 \n
+///
+////////////////////////////////////////////////////////////////////////////////////////
+
+#include <boost/mpl/at.hpp>
+#include <boost/mpl/size.hpp>
+#include <boost/gil/gil_config.hpp>
+#include <boost/gil/extension/dynamic_image/dynamic_image_all.hpp>
+
+namespace boost { namespace gil {
+
+// need this for various meta functions.
+struct any_image_pixel_t       {};
+struct any_image_channel_t     {};
+struct any_image_color_space_t {};
+
+namespace detail {
+
+template <long N>
+struct construct_matched_t {
+    template <typename Images,typename Pred>
+    static bool apply(any_image<Images>& im,Pred pred) {
+        if (pred.template apply<typename mpl::at_c<Images,N-1>::type>()) {
+            typename mpl::at_c<Images,N-1>::type x;
+            im.move_in(x);
+            return true;
+        } else return construct_matched_t<N-1>::apply(im,pred);
+    }
+};
+template <>
+struct construct_matched_t<0> {
+    template <typename Images,typename Pred>
+    static bool apply(any_image<Images>&,Pred) {return false;}
+};
+
+// A function object that can be passed to apply_operation.
+// Given a predicate IsSupported taking a view type and returning an MPL boolean,
+// calls the apply method of OpClass with the view if the given view IsSupported, or throws an exception otherwise
+template <typename IsSupported, typename OpClass>
+class dynamic_io_fnobj {
+    OpClass* _op;
+
+    template <typename View>
+    void apply(const View& view,mpl::true_ ) {_op->apply(view);}
+
+    template <typename View, typename Info >
+    void apply( const View& view
+              , const Info& info
+              , const mpl::true_
+              )
+    {
+        _op->apply( view, info );
+    }
+
+    template <typename View>
+    void apply(const View& /* view */ ,mpl::false_)
+    {
+        throw std::ios_base::failure( "dynamic_io: unsupported view type for the given file format" );
+    }
+
+    template <typename View, typename Info >
+    void apply( const View& /* view */
+              , const Info& /* info */
+              , const mpl::false_
+              )
+    {
+        throw std::ios_base::failure( "dynamic_io: unsupported view type for the given file format" );
+    }
+
+public:
+    dynamic_io_fnobj(OpClass* op) : _op(op) {}
+
+    typedef void result_type;
+
+    template <typename View>
+    void operator()(const View& view) {apply(view,typename IsSupported::template apply<View>::type());}
+
+    template< typename View, typename Info >
+    void operator()(const View& view, const Info& info )
+    {
+        apply( view
+             , info
+             , typename IsSupported::template apply< View >::type()
+             );
+    }
+
+};
+
+} // namespace detail
+
+/// \brief Within the any_image, constructs an image with the given dimensions
+///        and a type that satisfies the given predicate
+template <typename Images,typename Pred>
+inline bool construct_matched(any_image<Images>& im,Pred pred) {
+    return detail::construct_matched_t<mpl::size<Images>::value>::apply(im,pred);
+}
+
+template<>
+struct color_space_type< any_image_pixel_t >
+{
+    typedef any_image_color_space_t type;
+};
+
+
+} }  // namespace boost::gil
+
+#endif // BOOST_GIL_EXTENSION_TOOLBOX_DYNAMIC_IMAGES_HPP

Added: trunk/boost/gil/extension/toolbox/image_types.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/gil/extension/toolbox/image_types.hpp	2013-02-06 20:37:47 EST (Wed, 06 Feb 2013)
@@ -0,0 +1,24 @@
+/*
+    Copyright 2012 Christian Henning
+    Use, modification and distribution are subject to the Boost Software License,
+    Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt).
+*/
+
+/*************************************************************************************************/
+
+#ifndef BOOST_GIL_EXTENSION_TOOLBOX_METAFUNCTIONS_IMAGE_TYPES_HPP
+#define BOOST_GIL_EXTENSION_TOOLBOX_METAFUNCTIONS_IMAGE_TYPES_HPP
+
+////////////////////////////////////////////////////////////////////////////////////////
+/// \file image_types.hpp
+/// \brief Image Types for toolbox extension.
+/// \author Christian Henning \n
+///
+/// \date 2012 \n
+///
+////////////////////////////////////////////////////////////////////////////////////////
+
+#include <boost/gil/extension/toolbox/image_types/indexed_image.hpp>
+
+#endif // BOOST_GIL_EXTENSION_TOOLBOX_METAFUNCTIONS_IMAGE_TYPES_HPP

Added: trunk/boost/gil/extension/toolbox/image_types/indexed_image.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/gil/extension/toolbox/image_types/indexed_image.hpp	2013-02-06 20:37:47 EST (Wed, 06 Feb 2013)
@@ -0,0 +1,364 @@
+/*
+    Copyright 2012 Christian Henning
+    Use, modification and distribution are subject to the Boost Software License,
+    Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt).
+*/
+
+/*************************************************************************************************/
+
+#ifndef BOOST_GIL_EXTENSION_TOOLBOX_IMAGE_TYPES_INDEXED_IMAGE_HPP
+#define BOOST_GIL_EXTENSION_TOOLBOX_IMAGE_TYPES_INDEXED_IMAGE_HPP
+
+////////////////////////////////////////////////////////////////////////////////////////
+/// \file indexed_image.hpp
+/// \brief Indexed Image extension
+/// \author Christian Henning \n
+///
+/// \date 2012 \n
+///
+////////////////////////////////////////////////////////////////////////////////////////
+
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/utility/enable_if.hpp>
+
+#include <boost/gil/image.hpp>
+#include <boost/gil/extension/toolbox/metafunctions/is_bit_aligned.hpp>
+
+
+namespace boost{ namespace gil {
+
+typedef boost::gil::point2< std::ptrdiff_t > point_t;
+
+template< typename Locator >
+struct get_pixel_type_locator : mpl::if_< typename is_bit_aligned< typename Locator::value_type >::type
+                                        , typename Locator::reference
+                                        , typename Locator::value_type
+                                        > {};
+
+// used for virtual locator
+template< typename IndicesLoc
+        , typename PaletteLoc
+        >
+struct indexed_image_deref_fn_base
+{
+    typedef IndicesLoc indices_locator_t;
+    typedef PaletteLoc palette_locator_t;
+    //typedef typename get_pixel_type_locator< indices_locator_t >::type index_t;
+
+    typedef indexed_image_deref_fn_base     const_t;
+    typedef typename PaletteLoc::value_type value_type;
+    typedef value_type                      reference;
+    typedef value_type                      const_reference;
+    typedef point_t                         argument_type;
+    typedef reference                       result_type;
+
+    static const bool is_mutable = false;
+
+    indexed_image_deref_fn_base() {}
+
+    indexed_image_deref_fn_base( const indices_locator_t& indices_loc
+                               , const palette_locator_t& palette_loc
+                               )
+    : _indices_loc( indices_loc )
+    , _palette_loc( palette_loc )
+    {}
+
+    void set_indices( const indices_locator_t& indices_loc ) { _indices_loc = indices_loc; }
+    void set_palette( const palette_locator_t& palette_loc ) { _palette_loc = palette_loc; }
+
+    const indices_locator_t& indices() const { return _indices_loc; }
+    const palette_locator_t& palette() const { return _palette_loc; }
+
+protected:
+
+    indices_locator_t _indices_loc;
+    palette_locator_t _palette_loc;
+};
+
+
+// used for virtual locator
+template< typename IndicesLoc
+        , typename PaletteLoc
+        , typename Enable = void // there is specilization for integral indices
+        >
+struct indexed_image_deref_fn : indexed_image_deref_fn_base< IndicesLoc
+                                                           , PaletteLoc
+                                                           >
+{
+    typedef indexed_image_deref_fn_base< IndicesLoc
+                                       , PaletteLoc
+                                       > base_t;
+
+
+    indexed_image_deref_fn()
+    : base_t()
+    {}
+
+    indexed_image_deref_fn( const typename base_t::indices_locator_t& indices_loc
+                          , const typename base_t::palette_locator_t& palette_loc
+                          )
+    : base_t( indices_loc
+            , palette_loc
+            )
+    {}
+
+    typename base_t::result_type operator()( const point_t& p ) const
+    {
+        return * this->_palette_loc.xy_at( at_c<0>( *this->_indices_loc.xy_at( p )), 0 );
+    }
+};
+
+
+template< typename IndicesLoc
+        , typename PaletteLoc
+        >
+struct indexed_image_deref_fn< IndicesLoc
+                             , PaletteLoc
+                             , typename boost::enable_if< boost::is_integral< typename IndicesLoc::value_type > >::type
+                             > : indexed_image_deref_fn_base< IndicesLoc
+                                                            , PaletteLoc
+                                                            >
+{
+    typedef indexed_image_deref_fn_base< IndicesLoc
+                                       , PaletteLoc
+                                       > base_t;
+
+    indexed_image_deref_fn()
+    : base_t()
+    {}
+
+    indexed_image_deref_fn( const typename base_t::indices_locator_t& indices_loc
+                          , const typename base_t::palette_locator_t& palette_loc
+                          )
+    : base_t( indices_loc
+            , palette_loc
+            )
+    {}
+
+    typename base_t::result_type operator()( const point_t& p ) const
+    {
+        return *this->_palette_loc.xy_at( *this->_indices_loc.xy_at( p ), 0 );
+    }
+};
+
+template< typename IndicesLoc
+        , typename PaletteLoc
+        >
+struct indexed_image_locator_type
+{
+    typedef virtual_2d_locator< indexed_image_deref_fn< IndicesLoc
+                                                      , PaletteLoc
+                                                      >
+                              , false
+                              > type;
+};
+
+template< typename Locator > // indexed_image_locator_type< ... >::type
+class indexed_image_view : public image_view< Locator >
+{
+public:
+
+    typedef typename Locator::deref_fn_t deref_fn_t;
+    typedef typename deref_fn_t::indices_locator_t indices_locator_t;
+    typedef typename deref_fn_t::palette_locator_t palette_locator_t;
+
+    typedef indexed_image_view< Locator > const_t;
+
+    typedef image_view< indices_locator_t > indices_view_t;
+    typedef image_view< palette_locator_t > palette_view_t;
+
+    indexed_image_view()
+    : image_view< Locator >()
+    , _num_colors( 0 )
+    {}
+
+    indexed_image_view( const point_t& dimensions
+                      , std::size_t    num_colors
+                      , const Locator& locator
+                      )
+    : image_view< Locator >( dimensions, locator )
+    , _num_colors( num_colors )
+    {}
+
+    template< typename IndexedView >
+    indexed_image_view( const IndexedView& iv )
+    : image_view< Locator >( iv )
+    , _num_colors( iv._num_colors )
+    {}
+
+    const std::size_t num_colors() const { return _num_colors; }
+
+
+    const indices_locator_t& indices() const { return get_deref_fn().indices(); }
+    const palette_locator_t& palette() const { return get_deref_fn().palette(); }
+
+    const indices_view_t get_indices_view() const { return indices_view_t( this->dimensions(), indices() ); }
+    const palette_view_t get_palette_view() const { return palette_view_t( point_t( num_colors(), 1 )
+                                                                         , palette()
+                                                                         ); }
+
+private:
+
+    const deref_fn_t& get_deref_fn() const { return this->pixels().deref_fn(); }
+
+private:
+
+    template< typename Locator2 > friend class indexed_image_view;
+
+    std::size_t _num_colors;
+};
+
+
+template< typename Index
+        , typename Pixel
+        , typename IndicesAllocator = std::allocator< unsigned char >
+        , typename PalleteAllocator = std::allocator< unsigned char >
+        >
+class indexed_image
+{
+public:
+
+    typedef image< Index, false, IndicesAllocator > indices_t;
+    typedef image< Pixel, false, PalleteAllocator > palette_t;
+
+    typedef typename indices_t::view_t indices_view_t;
+    typedef typename palette_t::view_t palette_view_t;
+
+    typedef typename indices_t::const_view_t indices_const_view_t;
+    typedef typename palette_t::const_view_t palette_const_view_t;
+
+    typedef typename indices_view_t::locator indices_locator_t;
+    typedef typename palette_view_t::locator palette_locator_t;
+
+    typedef typename indexed_image_locator_type< indices_locator_t
+                                               , palette_locator_t
+                                               >::type locator_t;
+
+    typedef typename indices_t::coord_t x_coord_t;
+    typedef typename indices_t::coord_t y_coord_t;
+
+
+    typedef indexed_image_view< locator_t > view_t;
+    typedef typename view_t::const_t        const_view_t;
+
+    indexed_image( const x_coord_t   width = 0
+                 , const y_coord_t   height = 0
+                 , const std::size_t num_colors = 1
+                 , const std::size_t indices_alignment = 0
+                 , const std::size_t palette_alignment = 0
+                 )
+    : _indices( width     , height, indices_alignment, IndicesAllocator() )
+    , _palette( num_colors,      1, palette_alignment, PalleteAllocator() )
+    {
+        init( point_t( width, height ), num_colors );
+    }
+
+    indexed_image( const point_t&    dimensions
+                 , const std::size_t num_colors = 1
+                 , const std::size_t indices_alignment = 0
+                 , const std::size_t palette_alignment = 0
+                 )
+    : _indices( dimensions,    indices_alignment, IndicesAllocator() )
+    , _palette( num_colors, 1, palette_alignment, PalleteAllocator() )
+    {
+        init( dimensions, num_colors );
+    }
+
+    indexed_image( const indexed_image& img )
+    : _indices( img._indices )
+    , _palette( img._palette )
+    {}
+
+    template <typename Pixel2, typename Index2>
+    indexed_image( const indexed_image< Pixel2, Index2 >& img )
+    {
+        _indices = img._indices;
+        _palette = img._palette;
+    }
+
+    indexed_image& operator= ( const indexed_image& img )
+    {
+        _indices = img._indices;
+        _palette = img._palette;
+
+        return *this;
+    }
+
+    indices_const_view_t get_indices_const_view() const { return static_cast< indices_const_view_t >( _view.get_indices_view()); }
+    palette_const_view_t get_palette_const_view() const { return static_cast< palette_const_view_t >( _view.get_palette_view()); }
+
+    indices_view_t get_indices_view() { return _view.get_indices_view(); }
+    palette_view_t get_palette_view() { return _view.get_palette_view(); }
+
+public:
+
+    view_t _view;
+
+private:
+
+    void init( const point_t&    dimensions
+             , const std::size_t num_colors
+             )
+    {
+        typedef indexed_image_deref_fn< indices_locator_t
+                                      , palette_locator_t
+                                      > defer_fn_t;
+
+        defer_fn_t deref_fn( view( _indices ).xy_at( 0, 0 )
+                           , view( _palette ).xy_at( 0, 0 )
+                           );
+
+        locator_t locator( point_t( 0, 0 )
+                         , point_t( 1, 1 )
+                         , deref_fn
+                         );
+
+        _view = view_t( dimensions
+                      , num_colors
+                      , locator
+                      );
+    }
+
+private:
+
+    indices_t _indices;
+    palette_t _palette;
+};
+
+template< typename Index
+        , typename Pixel
+        >
+inline
+const typename indexed_image< Index, Pixel >::view_t& view( indexed_image< Index, Pixel >& img )
+{
+    return img._view;
+}
+
+template< typename Index
+        , typename Pixel
+        >
+inline
+const typename indexed_image< Index, Pixel >::const_view_t const_view( indexed_image< Index, Pixel >& img )
+{
+    return static_cast< const typename indexed_image< Index, Pixel >::const_view_t>( img._view );
+}
+
+// Whole image has one color and all indices are set to 0.
+template< typename Locator
+        , typename Value
+        >
+void fill_pixels( const indexed_image_view< Locator >& view
+                , const Value&                         value
+                )
+{
+    typedef indexed_image_view< Locator > view_t;
+
+    fill_pixels( view.get_indices_view(), typename view_t::indices_view_t::value_type( 0 ));
+    *view.get_palette_view().begin() = value;
+}
+
+} // namespace gil
+} // namespace boost
+
+#endif // BOOST_GIL_EXTENSION_TOOLBOX_IMAGE_TYPES_INDEXED_IMAGE_HPP

Added: trunk/boost/gil/extension/toolbox/metafunctions.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/gil/extension/toolbox/metafunctions.hpp	2013-02-06 20:37:47 EST (Wed, 06 Feb 2013)
@@ -0,0 +1,31 @@
+/*
+    Copyright 2012 Christian Henning
+    Use, modification and distribution are subject to the Boost Software License,
+    Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt).
+*/
+
+/*************************************************************************************************/
+
+#ifndef BOOST_GIL_EXTENSION_TOOLBOX_METAFUNCTIONS_HPP
+#define BOOST_GIL_EXTENSION_TOOLBOX_METAFUNCTIONS_HPP
+
+////////////////////////////////////////////////////////////////////////////////////////
+/// \file metafunctions.hpp
+/// \brief Header for toolbox's metafunctions.
+/// \author Christian Henning \n
+///
+/// \date 2012 \n
+///
+////////////////////////////////////////////////////////////////////////////////////////
+
+#include <boost/gil/extension/toolbox/metafunctions/channel_type.hpp>
+#include <boost/gil/extension/toolbox/metafunctions/channel_view.hpp>
+#include <boost/gil/extension/toolbox/metafunctions/get_num_bits.hpp>
+#include <boost/gil/extension/toolbox/metafunctions/get_pixel_type.hpp>
+#include <boost/gil/extension/toolbox/metafunctions/is_bit_aligned.hpp>
+#include <boost/gil/extension/toolbox/metafunctions/is_homogeneous.hpp>
+#include <boost/gil/extension/toolbox/metafunctions/is_similar.hpp>
+#include <boost/gil/extension/toolbox/metafunctions/pixel_bit_size.hpp>
+
+#endif // BOOST_GIL_EXTENSION_TOOLBOX_METAFUNCTIONS_HPP

Added: trunk/boost/gil/extension/toolbox/metafunctions/channel_type.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/gil/extension/toolbox/metafunctions/channel_type.hpp	2013-02-06 20:37:47 EST (Wed, 06 Feb 2013)
@@ -0,0 +1,111 @@
+/*
+    Copyright 2012 Christian Henning, Andreas Pokorny, Lubomir Bourdev
+    Use, modification and distribution are subject to the Boost Software License,
+    Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt).
+*/
+
+/*************************************************************************************************/
+
+#ifndef BOOST_GIL_EXTENSION_TOOLBOX_METAFUNCTIONS_CHANNEL_TYPE_HPP
+#define BOOST_GIL_EXTENSION_TOOLBOX_METAFUNCTIONS_CHANNEL_TYPE_HPP
+
+////////////////////////////////////////////////////////////////////////////////////////
+/// \file channel_type.hpp
+/// \brief channel_type metafunction.
+/// \author Christian Henning, Andreas Pokorny, Lubomir Bourdev \n
+///
+/// \date 2012 \n
+///
+////////////////////////////////////////////////////////////////////////////////////////
+
+#include <boost/utility/enable_if.hpp>
+
+#include <boost/mpl/at.hpp>
+
+#include <boost/gil/bit_aligned_pixel_reference.hpp>
+#include <boost/gil/channel.hpp>
+
+#include <boost/gil/extension/toolbox/dynamic_images.hpp>
+
+#include <boost/gil/extension/toolbox/metafunctions/get_num_bits.hpp>
+#include <boost/gil/extension/toolbox/metafunctions/is_homogeneous.hpp>
+
+namespace boost{ namespace gil {
+
+/// channel_type metafunction
+/// \brief Generates the channel type for 
+
+template <typename B, typename C, typename L, bool M>  
+struct gen_chan_ref
+{
+	typedef packed_dynamic_channel_reference< B
+	                                        , mpl::at_c< C, 0 >::type::value
+	                                        , M
+	                                        > type;
+};
+
+//! This implementation works for bit_algined_pixel_reference 
+//! with a homogeneous channel layout. 
+//! The result type will be a packed_dynamic_channel_reference, since the 
+//! offset info will be missing. 
+
+// bit_aligned_pixel_reference
+template <typename B, typename C, typename L, bool M>  
+struct channel_type< bit_aligned_pixel_reference<B,C,L,M> > 
+	: lazy_enable_if< is_homogeneous< bit_aligned_pixel_reference< B, C, L, M > >
+                    , gen_chan_ref< B, C, L, M >
+		            > {};
+
+template <typename B, typename C, typename L, bool M>  
+struct channel_type<const bit_aligned_pixel_reference<B,C,L,M> > 
+	: lazy_enable_if< is_homogeneous< bit_aligned_pixel_reference< B, C, L, M > >
+	                , gen_chan_ref< B, C, L, M >
+		            > {};
+
+template <typename B, typename C, typename L>  
+struct gen_chan_ref_p
+{
+	typedef packed_dynamic_channel_reference< B
+	                                        , get_num_bits< typename mpl::at_c<C,0>::type>::value
+	                                        , true
+	                                        > type;
+};
+
+// packed_pixel
+template < typename BitField
+         , typename ChannelRefVec
+         , typename Layout
+         >
+struct channel_type< packed_pixel< BitField
+                                 , ChannelRefVec
+                                 , Layout
+                                 >
+                   > : lazy_enable_if< is_homogeneous< packed_pixel< BitField
+                                                                   , ChannelRefVec
+                                                                   , Layout
+                                                                   >
+                                                     >
+                                     , gen_chan_ref_p< BitField
+                                                     , ChannelRefVec
+                                                     , Layout
+                                                     >
+		                             > {};
+
+template <typename B, typename C, typename L>  
+struct channel_type< const packed_pixel< B, C, L > > 
+	: lazy_enable_if< is_homogeneous<packed_pixel< B, C, L > >
+	                , gen_chan_ref_p< B, C, L >
+		            >
+{};
+
+template<>
+struct channel_type< any_image_pixel_t >
+{
+    typedef any_image_channel_t type;
+};
+
+} // namespace gil
+} // namespace boost
+
+#endif // BOOST_GIL_EXTENSION_TOOLBOX_METAFUNCTIONS_CHANNEL_TYPE_HPP

Added: trunk/boost/gil/extension/toolbox/metafunctions/channel_view.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/gil/extension/toolbox/metafunctions/channel_view.hpp	2013-02-06 20:37:47 EST (Wed, 06 Feb 2013)
@@ -0,0 +1,79 @@
+/*
+    Copyright 2010 Fabien Castan, Christian Henning
+    Use, modification and distribution are subject to the Boost Software License,
+    Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt).
+*/
+
+/*************************************************************************************************/
+
+#ifndef BOOST_GIL_EXTENSION_TOOLBOX_CHANNEL_VIEW_HPP_INCLUDED
+#define BOOST_GIL_EXTENSION_TOOLBOX_CHANNEL_VIEW_HPP_INCLUDED
+
+////////////////////////////////////////////////////////////////////////////////////////
+/// \file channel_view.hpp
+/// \brief Helper to generate channel_view type.
+/// \author Fabien Castan, Christian Henning \n
+///
+/// \date   2010 \n
+///
+////////////////////////////////////////////////////////////////////////////////////////
+
+#include <boost/gil/gil_all.hpp>
+
+namespace boost {
+namespace gil {
+
+template < typename Channel
+         , typename View
+         >
+struct channel_type_to_index
+{
+    static const int value = gil::detail::type_to_index< typename color_space_type< View >::type // color (mpl::vector)
+                                                       , Channel                                 // channel type
+                                                       >::type::value;                           //< index of the channel in the color (mpl::vector)
+};
+
+template< typename Channel
+        , typename View
+        >
+struct channel_view_type : public kth_channel_view_type< channel_type_to_index< Channel
+                                                                              , View
+                                                                              >::value
+                                                       , View
+                                                       >
+{
+    static const int index = channel_type_to_index< Channel
+                                                  , View
+                                                  >::value;
+                                                  
+    typedef kth_channel_view_type< index
+                                 , View
+                                 > parent_t;
+
+    typedef typename parent_t::type type;
+
+
+    static type make( const View& src )
+    {
+        return parent_t::make( src );
+    }
+};
+
+/// \ingroup ImageViewTransformationsKthChannel
+template< typename Channel
+        , typename View
+        >
+typename channel_view_type< Channel
+                          , View
+                          >::type channel_view( const View& src )
+{
+   return channel_view_type< Channel
+                           , View
+                           >::make( src );
+}
+
+} // namespace gil
+} // namespace boost
+
+#endif // BOOST_GIL_EXTENSION_TOOLBOX_CHANNEL_VIEW_HPP_INCLUDED

Added: trunk/boost/gil/extension/toolbox/metafunctions/get_num_bits.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/gil/extension/toolbox/metafunctions/get_num_bits.hpp	2013-02-06 20:37:47 EST (Wed, 06 Feb 2013)
@@ -0,0 +1,60 @@
+/*
+    Copyright 2012 Christian Henning, Andreas Pokorny, Lubomir Bourdev
+    Use, modification and distribution are subject to the Boost Software License,
+    Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt).
+*/
+
+/*************************************************************************************************/
+
+#ifndef BOOST_GIL_EXTENSION_TOOLBOX_METAFUNCTIONS_GET_NUM_BITS_HPP
+#define BOOST_GIL_EXTENSION_TOOLBOX_METAFUNCTIONS_GET_NUM_BITS_HPP
+
+////////////////////////////////////////////////////////////////////////////////////////
+/// \file get_num_bits.hpp
+/// \brief get_num_bits metafunction.
+/// \author Christian Henning, Andreas Pokorny, Lubomir Bourdev \n
+///
+/// \date 2012 \n
+///
+////////////////////////////////////////////////////////////////////////////////////////
+
+#include <boost/gil/channel.hpp>
+
+namespace boost{ namespace gil {
+
+/// get_num_bits metafunctions
+/// \brief Determines the numbers of bits for the given channel type.
+
+template <typename T>
+struct get_num_bits;
+
+template< typename B, int I, int S, bool M >
+struct get_num_bits< packed_channel_reference< B, I, S, M > >
+{
+    BOOST_STATIC_CONSTANT( int, value = S );
+};
+
+template<typename B,int I, int S, bool M>
+struct get_num_bits< const packed_channel_reference< B, I, S, M > >
+{
+    BOOST_STATIC_CONSTANT( int, value = S );
+};
+
+template<typename B, int I, bool M>
+struct get_num_bits< packed_dynamic_channel_reference< B, I, M > >
+{
+    BOOST_STATIC_CONSTANT( int, value = I );
+};
+
+template<typename b, int i, bool m>
+struct get_num_bits< const packed_dynamic_channel_reference< b, i, m > >
+{
+    BOOST_STATIC_CONSTANT( int, value = i );
+};
+
+
+} // namespace gil
+} // namespace boost
+
+#endif // BOOST_GIL_EXTENSION_TOOLBOX_METAFUNCTIONS_GET_NUM_BITS_HPP

Added: trunk/boost/gil/extension/toolbox/metafunctions/get_pixel_type.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/gil/extension/toolbox/metafunctions/get_pixel_type.hpp	2013-02-06 20:37:47 EST (Wed, 06 Feb 2013)
@@ -0,0 +1,46 @@
+/*
+    Copyright 2012 Christian Henning, Andreas Pokorny, Lubomir Bourdev
+    Use, modification and distribution are subject to the Boost Software License,
+    Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt).
+*/
+
+/*************************************************************************************************/
+
+#ifndef BOOST_GIL_EXTENSION_TOOLBOX_METAFUNCTIONS_GET_PIXEL_TYPE_HPP
+#define BOOST_GIL_EXTENSION_TOOLBOX_METAFUNCTIONS_GET_PIXEL_TYPE_HPP
+
+////////////////////////////////////////////////////////////////////////////////////////
+/// \file get_pixel_type.hpp
+/// \brief get_pixel_type metafunction.
+/// \author Christian Henning, Andreas Pokorny, Lubomir Bourdev \n
+///
+/// \date 2012 \n
+///
+////////////////////////////////////////////////////////////////////////////////////////
+
+#include <boost/gil/extension/toolbox/dynamic_images.hpp>
+#include <boost/gil/extension/toolbox/metafunctions/is_bit_aligned.hpp>
+
+namespace boost{ namespace gil {
+
+/// get_pixel_type metafunction
+/// \brief Depending on Image this function generates either 
+///        the pixel type or the reference type in case
+///        the image is bit_aligned.
+template< typename View >
+struct get_pixel_type : mpl::if_< typename is_bit_aligned< typename View::value_type >::type
+                                , typename View::reference
+                                , typename View::value_type
+                                > {};
+
+template< typename ImageViewTypes >
+struct get_pixel_type< any_image_view< ImageViewTypes > >
+{
+    typedef any_image_pixel_t type;
+};
+
+} // namespace gil
+} // namespace boost
+
+#endif // BOOST_GIL_EXTENSION_TOOLBOX_METAFUNCTIONS_GET_PIXEL_TYPE_HPP

Added: trunk/boost/gil/extension/toolbox/metafunctions/gil_extensions.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/gil/extension/toolbox/metafunctions/gil_extensions.hpp	2013-02-06 20:37:47 EST (Wed, 06 Feb 2013)
@@ -0,0 +1,42 @@
+/*
+    Copyright 2010 Christian Henning, Andreas Pokorny, Lubomir Bourdev
+    Use, modification and distribution are subject to the Boost Software License,
+    Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt).
+*/
+
+/*************************************************************************************************/
+
+#ifndef BOOST_GIL_EXTENSION_TOOLBOX_GIL_EXTENSIONS_HPP_INCLUDED
+#define BOOST_GIL_EXTENSION_TOOLBOX_GIL_EXTENSIONS_HPP_INCLUDED
+
+////////////////////////////////////////////////////////////////////////////////////////
+/// \file
+/// \brief Definitions of is_bit_aligned, is_homogeneous, and is_similar metafunctions and
+///        some other goodies.
+/// \author Christian Henning, Andreas Pokorny, Lubomir Bourdev \n
+///
+/// \date   2008 \n
+///
+////////////////////////////////////////////////////////////////////////////////////////
+
+#include <boost/gil/gil_all.hpp>
+
+
+#include <boost/mpl/if.hpp>
+
+#include <boost/gil/extension/toolbox/dynamic_images.hpp>
+
+namespace boost { namespace gil {
+
+
+/// other goodies
+
+
+
+
+
+} // namespace gil
+} // namespace boost
+
+#endif // BOOST_GIL_EXTENSION_TOOLBOX_GIL_EXTENSIONS_HPP_INCLUDED

Added: trunk/boost/gil/extension/toolbox/metafunctions/is_bit_aligned.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/gil/extension/toolbox/metafunctions/is_bit_aligned.hpp	2013-02-06 20:37:47 EST (Wed, 06 Feb 2013)
@@ -0,0 +1,47 @@
+/*
+    Copyright 2012 Christian Henning, Andreas Pokorny, Lubomir Bourdev
+    Use, modification and distribution are subject to the Boost Software License,
+    Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt).
+*/
+
+/*************************************************************************************************/
+
+#ifndef BOOST_GIL_EXTENSION_TOOLBOX_METAFUNCTIONS_IS_BIT_ALIGNED_TYPE_HPP
+#define BOOST_GIL_EXTENSION_TOOLBOX_METAFUNCTIONS_IS_BIT_ALIGNED_TYPE_HPP
+
+////////////////////////////////////////////////////////////////////////////////////////
+/// \file is_bit_aligned.hpp
+/// \brief is_bit_aligned metafunction.
+/// \author Christian Henning, Andreas Pokorny, Lubomir Bourdev \n
+///
+/// \date 2012 \n
+///
+////////////////////////////////////////////////////////////////////////////////////////
+
+#include <boost/gil/bit_aligned_pixel_reference.hpp>
+
+namespace boost{ namespace gil {
+
+/// is_bit_aligned metafunctions
+/// \brief Determines whether the given type is bit_aligned.
+
+template< typename PixelRef >
+struct is_bit_aligned : mpl::false_{};
+
+template <typename B, typename C, typename L, bool M>  
+struct is_bit_aligned<bit_aligned_pixel_reference<B,C,L,M> > : mpl::true_{};
+
+template <typename B, typename C, typename L, bool M>  
+struct is_bit_aligned<const bit_aligned_pixel_reference<B,C,L,M> > : mpl::true_{};
+
+template <typename B, typename C, typename L>  
+struct is_bit_aligned<packed_pixel<B,C,L> > : mpl::true_{};
+
+template <typename B, typename C, typename L>  
+struct is_bit_aligned<const packed_pixel<B,C,L> > : mpl::true_{};
+
+} // namespace gil
+} // namespace boost
+
+#endif // BOOST_GIL_EXTENSION_TOOLBOX_METAFUNCTIONS_IS_BIT_ALIGNED_TYPE_HPP

Added: trunk/boost/gil/extension/toolbox/metafunctions/is_homogeneous.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/gil/extension/toolbox/metafunctions/is_homogeneous.hpp	2013-02-06 20:37:47 EST (Wed, 06 Feb 2013)
@@ -0,0 +1,93 @@
+/*
+    Copyright 2012 Christian Henning, Andreas Pokorny, Lubomir Bourdev
+    Use, modification and distribution are subject to the Boost Software License,
+    Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt).
+*/
+
+/*************************************************************************************************/
+
+#ifndef BOOST_GIL_EXTENSION_TOOLBOX_METAFUNCTIONS_IS_HOMOGENEOUS_HPP
+#define BOOST_GIL_EXTENSION_TOOLBOX_METAFUNCTIONS_IS_HOMOGENEOUS_HPP
+
+////////////////////////////////////////////////////////////////////////////////////////
+/// \file is_homogeneous.hpp
+/// \brief is_homogeneous metafunction
+/// \author Christian Henning, Andreas Pokorny, Lubomir Bourdev \n
+///
+/// \date 2012 \n
+///
+////////////////////////////////////////////////////////////////////////////////////////
+
+#include <boost/mpl/at.hpp>
+
+#include <boost/gil/pixel.hpp>
+
+
+namespace boost{ namespace gil {
+
+/// is_homogeneous metafunctions
+/// \brief Determines if a pixel types are homogeneous.
+
+template<typename C,typename CMP, int Next, int Last> struct is_homogeneous_impl;
+
+template<typename C,typename CMP, int Last>
+struct is_homogeneous_impl<C,CMP,Last,Last> : mpl::true_{};
+
+template<typename C,typename CMP, int Next, int Last>
+struct is_homogeneous_impl : mpl::and_< is_homogeneous_impl< C, CMP,Next + 1, Last >
+                                      , is_same< CMP, typename mpl::at_c<C,Next>::type
+                                      > > {};
+
+template < typename P > struct is_homogeneous : mpl::false_ {};
+
+// pixel
+template < typename C, typename L > struct is_homogeneous< pixel<C,L> > : mpl::true_ {};
+template < typename C, typename L > struct is_homogeneous<const pixel<C,L> > : mpl::true_ {};
+template < typename C, typename L > struct is_homogeneous< pixel<C,L>& > : mpl::true_ {};
+template < typename C, typename L > struct is_homogeneous<const pixel<C,L>& > : mpl::true_ {};
+
+// planar pixel reference
+template <typename Channel, typename ColorSpace>
+struct is_homogeneous< planar_pixel_reference< Channel, ColorSpace > > : mpl::true_ {};
+template <typename Channel, typename ColorSpace>
+struct is_homogeneous< const planar_pixel_reference< Channel, ColorSpace > > : mpl::true_ {};
+
+template<typename C,typename CMP, int I,int Last>
+struct is_homogeneous_impl_p {};
+
+// for packed_pixel
+template <typename B, typename C, typename L >
+struct is_homogeneous<packed_pixel< B, C, L > > 
+	: is_homogeneous_impl_p< C 
+                           , typename mpl::at_c< C, 0 >::type
+                           , 1
+                           , mpl::size< C >::type::value
+                           > {};
+
+template< typename B
+        , typename C
+        , typename L
+        >  
+struct is_homogeneous< const packed_pixel< B, C, L > > 
+	: is_homogeneous_impl_p< C
+	                       , typename mpl::at_c<C,0>::type
+	                       , 1
+	                       , mpl::size< C >::type::value
+	                       > {};
+
+// for bit_aligned_pixel_reference
+template <typename B, typename C, typename L, bool M>  
+struct is_homogeneous<bit_aligned_pixel_reference<B,C,L,M> > 
+	: is_homogeneous_impl<C,typename mpl::at_c<C,0>::type,1,mpl::size<C>::type::value>
+{};
+
+template <typename B, typename C, typename L, bool M>  
+struct is_homogeneous<const bit_aligned_pixel_reference<B,C,L,M> > 
+	: is_homogeneous_impl<C,typename mpl::at_c<C,0>::type,1,mpl::size<C>::type::value>
+{};
+
+} // namespace gil
+} // namespace boost
+
+#endif // BOOST_GIL_EXTENSION_TOOLBOX_METAFUNCTIONS_IS_HOMOGENEOUS_HPP

Added: trunk/boost/gil/extension/toolbox/metafunctions/is_similar.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/gil/extension/toolbox/metafunctions/is_similar.hpp	2013-02-06 20:37:47 EST (Wed, 06 Feb 2013)
@@ -0,0 +1,43 @@
+/*
+    Copyright 2012 Christian Henning, Andreas Pokorny, Lubomir Bourdev
+    Use, modification and distribution are subject to the Boost Software License,
+    Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt).
+*/
+
+/*************************************************************************************************/
+
+#ifndef BOOST_GIL_EXTENSION_TOOLBOX_METAFUNCTIONS_IS_SIMILAR_HPP
+#define BOOST_GIL_EXTENSION_TOOLBOX_METAFUNCTIONS_IS_SIMILAR_HPP
+
+////////////////////////////////////////////////////////////////////////////////////////
+/// \file is_similar.hpp
+/// \brief is_similar metafunction.
+/// \author Christian Henning, Andreas Pokorny, Lubomir Bourdev \n
+///
+/// \date 2012 \n
+///
+////////////////////////////////////////////////////////////////////////////////////////
+
+#include <boost/gil/channel.hpp>
+
+namespace boost{ namespace gil {
+
+/// is_similar metafunctions
+/// \brief Determines if two pixel types are similar.
+
+template< typename A, typename B >
+struct is_similar : mpl::false_ {};
+
+template<typename A>
+struct is_similar< A, A > : mpl::true_ {};
+
+template<typename B,int I, int S, bool M, int I2>
+struct is_similar< packed_channel_reference< B,  I, S, M >
+                 , packed_channel_reference< B, I2, S, M >
+                 > : mpl::true_ {};
+
+} // namespace gil
+} // namespace boost
+
+#endif // BOOST_GIL_EXTENSION_TOOLBOX_METAFUNCTIONS_IS_SIMILAR_HPP

Added: trunk/boost/gil/extension/toolbox/metafunctions/pixel_bit_size.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/gil/extension/toolbox/metafunctions/pixel_bit_size.hpp	2013-02-06 20:37:47 EST (Wed, 06 Feb 2013)
@@ -0,0 +1,55 @@
+/*
+    Copyright 2012 Christian Henning, Andreas Pokorny, Lubomir Bourdev
+    Use, modification and distribution are subject to the Boost Software License,
+    Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt).
+*/
+
+/*************************************************************************************************/
+
+#ifndef BOOST_GIL_EXTENSION_TOOLBOX_METAFUNCTIONS_PIXEL_BIT_SIZE_HPP
+#define BOOST_GIL_EXTENSION_TOOLBOX_METAFUNCTIONS_PIXEL_BIT_SIZE_HPP
+
+////////////////////////////////////////////////////////////////////////////////////////
+/// \file pixel_bit_size.hpp
+/// \brief pixel_bit_size metafunction.
+/// \author Christian Henning, Andreas Pokorny, Lubomir Bourdev \n
+///
+/// \date 2012 \n
+///
+////////////////////////////////////////////////////////////////////////////////////////
+
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/accumulate.hpp>
+
+#include <boost/gil/bit_aligned_pixel_reference.hpp>
+#include <boost/gil/packed_pixel.hpp>
+
+namespace boost{ namespace gil {
+
+/// pixel_bit_size metafunctions
+/// \brief Accumulates the all channel size.
+/// 
+/// \code
+/// typedef bit_aligned_image5_type< 16, 16, 16, 8, 8, devicen_layout_t< 5 > >::type image_t;
+/// const int size = pixel_bit_size<image_t::view_t::reference>::value;
+/// \endcode
+template< typename PixelRef >
+struct pixel_bit_size : mpl::int_<0> {};
+
+template <typename B, typename C, typename L, bool M>  
+struct pixel_bit_size<bit_aligned_pixel_reference<B,C,L,M> > : mpl::int_< mpl::accumulate< C, mpl::int_<0>, mpl::plus<mpl::_1, mpl::_2> >::type::value >{};
+
+template <typename B, typename C, typename L, bool M>  
+struct pixel_bit_size<const bit_aligned_pixel_reference<B,C,L,M> > : mpl::int_< mpl::accumulate< C, mpl::int_<0>, mpl::plus<mpl::_1, mpl::_2> >::type::value >{};
+
+template <typename B, typename C, typename L>  
+struct pixel_bit_size<packed_pixel<B,C,L> > : mpl::int_< mpl::accumulate< C, mpl::int_<0>, mpl::plus<mpl::_1, mpl::_2> >::type::value >{};
+
+template <typename B, typename C, typename L>  
+struct pixel_bit_size<const packed_pixel<B,C,L> > : mpl::int_< mpl::accumulate< C, mpl::int_<0>, mpl::plus<mpl::_1, mpl::_2> >::type::value >{};
+
+} // namespace gil
+} // namespace boost
+
+#endif // BOOST_GIL_EXTENSION_TOOLBOX_METAFUNCTIONS_PIXEL_BIT_SIZE_HPP

Added: trunk/boost/gil/extension/toolbox/toolbox.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/gil/extension/toolbox/toolbox.hpp	2013-02-06 20:37:47 EST (Wed, 06 Feb 2013)
@@ -0,0 +1,29 @@
+/*
+    Copyright 2012 Christian Henning
+    Use, modification and distribution are subject to the Boost Software License,
+    Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt).
+*/
+
+/*************************************************************************************************/
+
+#ifndef BOOST_GIL_EXTENSION_TOOLBOX_TOOLBOX_HPP
+#define BOOST_GIL_EXTENSION_TOOLBOX_TOOLBOX_HPP
+
+////////////////////////////////////////////////////////////////////////////////////////
+/// \file toolbox.hpp
+/// \brief Main header for toolbox extension.
+/// \author Christian Henning \n
+///
+/// \date 2012 \n
+///
+////////////////////////////////////////////////////////////////////////////////////////
+
+#include <boost/gil/extension/toolbox/color_converters.hpp>
+#include <boost/gil/extension/toolbox/color_spaces.hpp>
+#include <boost/gil/extension/toolbox/image_types.hpp>
+#include <boost/gil/extension/toolbox/metafunctions.hpp>
+
+#include <boost/gil/extension/toolbox/dynamic_images.hpp>
+
+#endif // BOOST_GIL_EXTENSION_TOOLBOX_TOOLBOX_HPP