[Boost-commit] svn:boost r60953 - in sandbox/gil/boost/gil/extension/io2: . detail

Subject: [Boost-commit] svn:boost r60953 - in sandbox/gil/boost/gil/extension/io2: . detail
From: dsaritz_at_[hidden]
Date: 2010-03-30 12:41:40

Author: psiha
Date: 2010-03-30 12:41:39 EDT (Tue, 30 Mar 2010)
New Revision: 60953
URL: http://svn.boost.org/trac/boost/changeset/60953

Log:
Renamed the gp_*_bitmap classes to gp_*_image classes.

Added a first prototype/skeleton for the formatted_image<> class. Test-used it in the gp_image class.

Added the "gp_supported_pixel_formats" typedef, "roi" class, "desired_alignment" static constant and the current_image_type_id() member function as required by the formatted_image<> class.
Made the gp_image-from-IStream constructor public.
Removed some gp_image member functions that are now provided by the base class.
Renamed the gp_image::get_dimensions() member function to dimensions() to conform to the GIL image/view interface.

Added the first implementation of the view class for the gp_image class/backend.

Added Steven Watanabe's not-yet-official switch_ library to the detail folder as an internal implementation detail.

Removed some no-longer valid/relevant comments.
Added:
   sandbox/gil/boost/gil/extension/io2/detail/
   sandbox/gil/boost/gil/extension/io2/detail/switch.hpp   (contents, props changed)
   sandbox/gil/boost/gil/extension/io2/formatted_image.hpp   (contents, props changed)
Text files modified: 
   sandbox/gil/boost/gil/extension/io2/gp_private_base.hpp |   287 +++++++++++++++++++++++++++++++-------- 
   sandbox/gil/boost/gil/extension/io2/gp_private_io.hpp   |    44 +++---                                  
   2 files changed, 245 insertions(+), 86 deletions(-)

Added: sandbox/gil/boost/gil/extension/io2/detail/switch.hpp
==============================================================================
--- (empty file)
+++ sandbox/gil/boost/gil/extension/io2/detail/switch.hpp	2010-03-30 12:41:39 EDT (Tue, 30 Mar 2010)
@@ -0,0 +1,136 @@
+// switch.hpp
+//
+// Copyright (c) 2006-2007
+// Steven Watanabe
+//
+// Distriuted under 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_SWITCH_HPP_INCLUDED
+#define BOOST_SWITCH_HPP_INCLUDED
+
+#include <stdexcept>
+#include <string>
+#include <boost/config.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/preprocessor/config/limits.hpp>
+#include <boost/preprocessor/repetition/repeat.hpp>
+#include <boost/preprocessor/iteration/local.hpp>
+#include <boost/mpl/size.hpp>
+#include <boost/mpl/at.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+#ifndef BOOST_SWITCH_LIMIT
+    #define BOOST_SWITCH_LIMIT 50
+#endif
+
+#if BOOST_SWITCH_LIMIT > BOOST_PP_LIMIT_REPEAT
+    #error BOOST_SWITCH_LIMIT exceeds Boost.Preprocessor limit
+#endif
+#if BOOST_SWITCH_LIMIT > BOOST_PP_LIMIT_ITERATION
+    #error BOOST_SWITCH_LIMIT exceeds Boost.Preprocessor limit
+#endif
+
+namespace boost {
+
+class bad_switch : public std::runtime_error {
+public:
+    template<class Int>
+    explicit bad_switch(Int v) :
+        std::runtime_error(
+            "boost::switch_ default case called -- none provided. value is: " +
+            boost::lexical_cast<std::string>(v)) {}
+};
+
+namespace switch_detail {
+
+// Avoid the need to create all the specializations of switch_impl
+// twice. Just pass this to switch_impl<N>::apply(...) when no
+// default is supplied.
+
+template<class R>
+inline R forced_return(typename boost::remove_reference<R>::type* r = 0) {
+    return(*r);
+}
+
+// Thanks to Stjepan Rajko for catching this.
+template<>
+inline void forced_return<void>(void*) {}
+template<>
+inline const void forced_return<const void>(const void*) {}
+template<>
+inline volatile void forced_return<volatile void>(volatile void*) {}
+template<>
+inline const volatile void forced_return<const volatile void>(const volatile void*) {}
+
+template<class R>
+struct throw_exception {
+    template<class Int>
+    R operator()(Int i) const {
+        boost::throw_exception(bad_switch(i));
+        return(switch_detail::forced_return<R>());
+    }
+};
+
+// N is the number of cases not including the default
+template<int N>
+struct switch_impl;
+
+// specialize for 0 separately to avoid warnings
+template<>
+struct switch_impl<0> {
+    template<class V, class Int, class F, class Default>
+    static typename F::result_type
+    apply(Int i, F, Default d BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(V)) {
+        return(d(i));
+    }
+};
+
+#define BOOST_SWITCH_CASE(z, n, data)                   \
+    case boost::mpl::at_c<data, n>::type::value: {      \
+        typename boost::mpl::at_c<data, n>::type arg;   \
+        return(f(arg));                                 \
+    }
+
+#define BOOST_SWITCH_IMPL(z, n, data)                                   \
+    template<>                                                          \
+    struct switch_impl<n> {                                             \
+        template<class V, class I, class F, class D>                    \
+        static typename F::result_type                                  \
+        apply(I i, F f, D d BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(V)) {   \
+            switch(i) {                                                 \
+                BOOST_PP_REPEAT_##z(n, BOOST_SWITCH_CASE, V)            \
+                default: return(d(i));                                  \
+            }                                                           \
+        }                                                               \
+    };
+
+#define BOOST_PP_LOCAL_LIMITS (1, BOOST_SWITCH_LIMIT)
+#define BOOST_PP_LOCAL_MACRO(n) BOOST_SWITCH_IMPL(1, n, ~)
+#include BOOST_PP_LOCAL_ITERATE()
+
+#undef BOOST_SWITCH_IMPL
+#undef BOOST_SWITCH_CASE
+
+}
+
+template<class V, class N, class F>
+inline typename F::result_type
+switch_(N n, F f BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(V)) {
+    typedef switch_detail::switch_impl<boost::mpl::size<V>::value> impl;
+    switch_detail::throw_exception<typename F::result_type> default_;
+    return(impl::template apply<V>(n, f, default_));
+}
+
+template<class V, class N, class F, class D>
+inline typename F::result_type
+switch_(N n, F f, D d BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(V)) {
+    typedef switch_detail::switch_impl<boost::mpl::size<V>::value> impl;
+    return(impl::template apply<V>(n, f, d));
+}
+
+}
+
+#endif

Added: sandbox/gil/boost/gil/extension/io2/formatted_image.hpp
==============================================================================
--- (empty file)
+++ sandbox/gil/boost/gil/extension/io2/formatted_image.hpp	2010-03-30 12:41:39 EDT (Tue, 30 Mar 2010)
@@ -0,0 +1,396 @@
+////////////////////////////////////////////////////////////////////////////////
+///
+/// \file formatted_image.hpp
+/// -------------------------
+///
+/// (to be) Base CRTP class for all image implementation classes/backends.
+///
+/// Copyright (c) Domagoj Saric 2010.
+///
+///  Use, modification and distribution is 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)
+///
+/// For more information, see http://www.boost.org
+///
+////////////////////////////////////////////////////////////////////////////////
+//------------------------------------------------------------------------------
+#pragma once
+#ifndef formatted_image_hpp__C34C1FB0_A4F5_42F3_9318_5805B88CFE49
+#define formatted_image_hpp__C34C1FB0_A4F5_42F3_9318_5805B88CFE49
+//------------------------------------------------------------------------------
+#include "../../gil_all.hpp"
+#include "io_error.hpp"
+
+#include "detail/switch.hpp"
+
+#include <boost/gil/extension/dynamic_image/any_image.hpp>
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/integral_c.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <boost/static_assert.hpp>
+//------------------------------------------------------------------------------
+namespace boost
+{
+//------------------------------------------------------------------------------
+namespace gil
+{
+//------------------------------------------------------------------------------
+
+struct assert_dimensions_match {};
+struct ensure_dimensions_match {};
+struct synchronize_dimensions  {};
+
+struct assert_formats_match {};
+struct ensure_formats_match {};
+struct synchronize_formats  {};
+
+
+namespace detail
+{
+//------------------------------------------------------------------------------
+
+
+typedef iterator_range<TCHAR const *> string_chunk_t;
+
+
+template <typename Pixel, bool planar>
+struct pixel_format_type : mpl::pair<Pixel, mpl::bool_<planar>> {};
+
+
+struct get_planar_pixel_iterator
+{
+    template <typename PixelFormatType>
+    struct apply
+    {
+        typedef planar_pixel_iterator
+                <
+                    typename channel_type    <typename PixelFormatType::first>::type,
+                    typename color_space_type<typename PixelFormatType::first>::type
+                > type;
+    };
+};
+
+struct get_plain_pixel_iterator
+{
+    template <typename PixelFormatType>
+    struct apply
+    {
+        typedef typename PixelFormatType::first * type;
+    };
+};
+
+
+template <typename PixelFormat>
+struct view_for_pixel_format
+{
+    typedef typename type_from_x_iterator
+            <
+                typename mpl::if_
+                <
+                    typename PixelFormat::second,
+                    get_planar_pixel_iterator,
+                    get_plain_pixel_iterator
+
+                >::type::apply<PixelFormat>::type
+            >::view_t type;
+};
+
+template <typename PixelFormats>
+struct views_for_pixel_formats
+    : public mpl::transform<PixelFormats, view_for_pixel_format<mpl::_1> > {};
+
+
+template <typename PixelFormat>
+struct const_view_for_pixel_format
+    :
+    public view_for_pixel_format<pixel_format_type<typename PixelFormat::first const, PixelFormat::second::value> >
+{};
+
+template <typename PixelFormats>
+struct const_views_for_pixel_formats
+    : public mpl::transform<PixelFormats, const_view_for_pixel_format<mpl::_1> > {};
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+///
+/// \class formatted_image_base
+///
+////////////////////////////////////////////////////////////////////////////////
+
+class formatted_image_base
+{
+public:
+    typedef point2<std::ptrdiff_t> dimensions_t;
+
+    typedef unsigned int image_type_id;
+    static image_type_id const unsupported_format = -1;
+
+protected:
+    static bool dimensions_match( dimensions_t const & mine, dimensions_t const & other ) { return mine == other; }
+    template <class View>
+    static bool dimensions_match( dimensions_t const & mine, View const & view ) { return dimensions_match( mine, view.dimensions(); ) }
+
+    static void do_ensure_dimensions_match( dimensions_t const & mine, dimensions_t const & other )
+    {
+        io_error_if( !dimensions_match( mine, other ), "input view size does not match source image size" );
+    }
+    template <class View>
+    static void do_ensure_dimensions_match( dimensions_t const & mine, View const & view )
+    {
+        do_ensure_dimensions_match( mine, view.dimensions() );
+    }
+
+    static void do_ensure_formats_match( bool const formats_match )
+    {
+        io_error_if( !formats_match, "input view format does not match source image format" );
+    }
+
+protected:
+    template <typename Image>
+    void do_synchronize_dimensions( Image & image, dimensions_t const & my_dimensions, unsigned int const alignment = 0 )
+    {
+        image.recreate( my_dimensions, alignment );
+    }
+
+protected:
+    struct assert_type_mismatch
+    {
+        typedef bool result_type;
+        template <typename Index>
+        result_type operator()( Index const & ) const { BOOST_ASSERT( !"input view format does not match source image format" ); return false; }
+    };
+
+    struct throw_type_mismatch
+    {
+        typedef void result_type;
+        result_type operator()() const { do_ensure_formats_match( false ); }
+    };
+
+    template <typename Type, typename SupportedPixelFormats>
+    struct check_type_match
+    {
+        typedef bool result_type;
+        template <typename SupportedFormatIndex>
+        result_type operator()( SupportedFormatIndex const & ) const
+        {
+            return worker<SupportedFormatIndex>( mpl::less<SupportedFormatIndex, mpl::size<SupportedPixelFormats> >() );
+        }
+
+        template <typename Index>
+        bool worker( mpl::true_ /*in-range*/ ) const
+        {
+            return is_same<Type, typename mpl::at<SupportedPixelFormats, Index>::type>::value;
+        }
+        template <typename Index>
+        bool worker( mpl::false_ /*not-in-range*/ ) const
+        {
+            return false;
+        }
+    };
+
+    template <typename Images>
+    class make_dynamic_image
+    {
+    public:
+        make_dynamic_image( any_image<Images> & image ) : image_( image ) {}
+
+        template <class Image>
+        Image & apply()
+        {
+            image_.move_in( Image() );
+            return image_._dynamic_cast<Image>();
+        }
+
+    protected:
+        any_image<Images> & image_;
+    };
+
+};
+
+
+////////////////////////////////////////////////////////////////////////////////
+///
+/// \class formatted_image
+///
+////////////////////////////////////////////////////////////////////////////////
+
+template <class Impl, class SupportedPixelFormats, class ROI>
+class formatted_image : public formatted_image_base
+{
+public:
+    //typedef typename any_image<typename Impl::supported_pixel_formats> any_image_t;
+    typedef SupportedPixelFormats supported_pixel_formats;
+    typedef ROI                   roi;
+
+    typedef any_image_view<typename const_views_for_pixel_formats<typename supported_pixel_formats>::type> const_view_t;
+    typedef any_image_view<typename views_for_pixel_formats      <typename supported_pixel_formats>::type>       view_t;
+
+    BOOST_STATIC_CONSTANT( bool, has_full_roi = (is_same<roi::offset_t, roi::point_t>::value) );
+
+protected:
+    typedef formatted_image base_t;
+
+private:
+    template <typename Images, typename dimensions_policy, typename formats_policy>
+    class read_dynamic_image : make_dynamic_image<Images>
+    {
+    private:
+        typedef make_dynamic_image<Images> base;
+    public:
+        typedef void result_type;
+
+        read_dynamic_image( any_image<Images> & image, Impl & impl )
+            :
+            base ( image ),
+            impl_( impl  )
+            {}
+
+        template <class Image>
+        void apply()
+        {
+            impl_.copy_to( base::apply<Image>(), dimensions_policy(), formats_policy() );
+        }
+
+        template <typename SupportedFormatIndex>
+        void operator()( SupportedFormatIndex const & )
+        {
+            apply<typename mpl::at<SupportedFormatIndex>::type>();
+        }
+
+    private:
+        Impl & impl_;
+    };
+
+    template <typename dimensions_policy, typename formats_policy>
+    class write_dynamic_view
+    {
+    public:
+        typedef void result_type;
+
+        write_dynamic_view( Impl & impl ) : impl_( impl  ) {}
+
+        template <class View>
+        void apply( View const & view )
+        {
+            impl_.copy_from( view, dimensions_policy(), formats_policy() );
+        }
+
+    private:
+        Impl & impl_;
+    };
+
+    struct write_is_supported
+    {
+        template<typename View>
+        struct apply : public Impl::is_supported<View> {};
+    };
+
+    typedef mpl::range_c<std::size_t, 0, mpl::size<supported_pixel_formats>::value> valid_type_id_range_t;
+
+private:
+    template <typename View>
+    bool formats_match()
+    {
+        Gdiplus::PixelFormat tzt = view_gp_format<View>::value;
+        return switch_<valid_type_id_range_t>
+        (
+            impl().current_image_type_id(),
+            check_type_match
+            <
+                pixel_format_type
+                <
+                    typename View::value_type,
+                    is_planar<typename View>::value
+                >,
+                supported_pixel_formats
+            >(),
+            assert_type_mismatch()
+        );
+    }
+
+    Impl & impl() { return static_cast<Impl &>( *this ); }
+
+public:
+    template <typename Image, typename DimensionsPolicy, typename FormatsPolicy>
+    void copy_to_image( Image & image, DimensionsPolicy const dimensions_policy, FormatsPolicy const formats_policy )
+    {
+        impl().copy_to( view( image ), dimensions_policy, formats_policy );
+    }
+
+    template <typename Image, typename FormatsPolicy>
+    void copy_to_image( Image & image, synchronize_dimensions, FormatsPolicy const formats_policy )
+    {
+        do_synchronize_dimensions( image, impl().dimensions(), Impl::desired_alignment );
+        impl().copy_to( view( image ), assert_dimensions_match(), formats_policy );
+    }
+
+    template <typename View>
+    void copy_to( View & view, assert_dimensions_match, assert_formats_match )
+    {
+        BOOST_ASSERT( dimensions_match( view.dimensions(), impl().dimensions() ) );
+        BOOST_ASSERT( formats_match<View>()                                      );
+        impl().copy_to_prepared_view( view );
+    }
+
+    template <typename View>
+    void copy_to( View & view, assert_dimensions_match, ensure_formats_match )
+    {
+        do_ensure_formats_match( formats_match<View>() );
+        copy_to( view, assert_dimensions_match(), assert_formats_match() );
+    }
+
+    template <typename View>
+    void copy_to( View & view, ensure_dimensions_match, assert_formats_match )
+    {
+        do_ensure_dimensions_match( formats_match<View>() );
+        copy_to( view, assert_dimensions_match, assert_formats_match );
+    }
+
+    template <typename Images, typename dimensions_policy, typename formats_policy>
+    void copy_to( any_image<Images> & im )
+    {
+        typedef mpl::range_c<std::size_t, 0, typename Impl::supported_pixel_formats> valid_range_t;
+        switch_<valid_range_t>
+        (
+            Impl::current_image_type_id(),
+            read_dynamic_image<Images, dimensions_policy, formats_policy>( im, *this ),
+            throw_type_mismatch()
+        );
+    }
+
+    template <typename Views, typename dimensions_policy, typename formats_policy>
+    void copy_from( any_image_view<Views> const & runtime_view, dimensions_policy, formats_policy )
+    {
+        typedef write_dynamic_view<dimensions_policy, formats_policy> op_t;
+        op_t op( *this );
+        apply_operation
+        (
+            runtime_view,
+            dynamic_io_fnobj<write_is_supported, op_t>( &op )
+        );
+    }
+
+    void save_to( std::string const & path )
+    {
+        impl().save_to( path.c_str() );
+    }
+
+    void save_to( std::wstring const & path )
+    {
+        impl().save_to( path.c_str() );
+    }
+
+};
+
+
+//------------------------------------------------------------------------------
+} // namespace detail
+//------------------------------------------------------------------------------
+} // namespace gil
+//------------------------------------------------------------------------------
+} // namespace boost
+//------------------------------------------------------------------------------
+#endif // formatted_image_hpp

Modified: sandbox/gil/boost/gil/extension/io2/gp_private_base.hpp
==============================================================================
--- sandbox/gil/boost/gil/extension/io2/gp_private_base.hpp	(original)
+++ sandbox/gil/boost/gil/extension/io2/gp_private_base.hpp	2010-03-30 12:41:39 EDT (Tue, 30 Mar 2010)
@@ -21,8 +21,9 @@
 //------------------------------------------------------------------------------
 #include "../../gil_all.hpp"
 #include "extern_lib_guard.hpp"
-#include "io_error.hpp"
+#include "formatted_image.hpp"
 #include "gp_private_istreams.hpp"
+#include "io_error.hpp"
 
 #include <boost/array.hpp>
 #include <boost/mpl/eval_if.hpp>
@@ -66,7 +67,6 @@
 typedef bgra_layout_t gp_alpha_layout_t;
 typedef bgr_layout_t  gp_layout_t;
 
-// An attempt to support packed pixel formats...still does not work/compile...:
 typedef packed_pixel_type<uint16_t, mpl::vector3_c<unsigned,5,6,5>, gp_layout_t>::type gp_rgb565_pixel_t;
 
 struct unpacked_view_gp_format
@@ -97,6 +97,16 @@
 };
 
 
+typedef mpl::vector5
+<
+    pixel_format_type<pixel<bits8 , gp_layout_t      >, false>,
+    pixel_format_type<pixel<bits8 , gp_alpha_layout_t>, false>,
+    pixel_format_type<pixel<bits16, gray_layout_t    >, false>,
+    pixel_format_type<gp_rgb565_pixel_t               , false>,
+    pixel_format_type<cmyk_t                          , false>
+> gp_supported_pixel_formats;
+
+
 template <class View>
 struct view_gp_format
     :
@@ -201,20 +211,49 @@
 };
 
 
+class gp_roi : public Gdiplus::Rect
+{
+public:
+    typedef INT                value_type;
+    typedef point2<value_type> point_t   ;
+
+    typedef point_t            offset_t  ;
+
+public:
+    gp_roi( value_type const x, value_type const y, value_type const width, value_type const height )
+        : Gdiplus::Rect( x, y, width, height ) {}
+
+    gp_roi( offset_t const offset, value_type const width, value_type const height )
+        : Gdiplus::Rect( Gdiplus::Point( offset.x, offset.y ), Gdiplus::Size( width, height ) ) {}
+
+    gp_roi( offset_t const top_left, offset_t const bottom_right )
+        : Gdiplus::Rect( Gdiplus::Point( top_left.x, top_left.y ), Gdiplus::Size( bottom_right.x - top_left.x, bottom_right.y - top_left.y ) ) {}
+};
+
+
 #if defined(BOOST_MSVC)
 #   pragma warning( push )
 #   pragma warning( disable : 4127 ) // "conditional expression is constant"
 #endif
 
-class gp_bitmap : gp_guard//, noncopyable
+class gp_image
+    :
+    private gp_guard,
+    public  detail::formatted_image<gp_image, gp_supported_pixel_formats, gp_roi>
 {
+public:
+    template <class View>
+    struct is_supported : detail::is_supported<view_gp_format<View>::value> {};
+
+    BOOST_STATIC_CONSTANT( unsigned int, desired_alignment = sizeof( Gdiplus::ARGB ) );
+    
 private:
     // - GP wants wide-char paths
     // - we received a narrow-char path
     // - we are using GP that means we are also using Windows
     // - on Windows a narrow-char path can only be up to MAX_PATH in length:
     //  http://msdn.microsoft.com/en-us/library/aa365247(VS.85).aspx#maxpath
-    // - it is therefor safe to use a fixed sized/stack buffer...
+    // - it is therefore safe to use a fixed sized/stack buffer...
     class wide_path
     {
     public:
@@ -222,8 +261,8 @@
         {
             BOOST_ASSERT( pFilename );
             BOOST_ASSERT( std::strlen( pFilename ) < wideFileName_.size() );
-            char  const * pSource     ( pFilename             );
-            WCHAR       * pDestination( wideFileName_.begin() );
+            char    const * pSource     ( pFilename             );
+            wchar_t       * pDestination( wideFileName_.begin() );
             do
             {
                 *pDestination++ = *pSource;
@@ -237,31 +276,32 @@
         boost::array<wchar_t, MAX_PATH> wideFileName_;
     };
 
-protected:
-    //  This one is intended only for derived classes because GP uses lazy
-    // evaluation of the stream so the stream object must preexist and also
-    // outlive the GpBitmap object.
-    explicit gp_bitmap( IStream & stream )
+
+public: /// \ingroup Construction
+    explicit gp_image( wchar_t const * const filename )
     {
-        ensure_result( Gdiplus::DllExports::GdipCreateBitmapFromStreamICM( &stream, &pBitmap_ ) );
+        ensure_result( Gdiplus::DllExports::GdipCreateBitmapFromFileICM( filename, &pBitmap_ ) );
         BOOST_ASSERT( pBitmap_ );
     }
 
-public:
-    explicit gp_bitmap( wchar_t const * const filename )
+    explicit gp_image( char const * const filename )
     {
-        ensure_result( Gdiplus::DllExports::GdipCreateBitmapFromFileICM( filename, &pBitmap_ ) );
+        ensure_result( Gdiplus::DllExports::GdipCreateBitmapFromFileICM( wide_path( filename ), &pBitmap_ ) );
         BOOST_ASSERT( pBitmap_ );
     }
 
-    explicit gp_bitmap( char const * const filename )
+    // The passed IStream object must outlive the GpBitmap object (GDI+ uses
+    // lazy evaluation).
+    explicit gp_image( IStream & stream )
     {
-        ensure_result( Gdiplus::DllExports::GdipCreateBitmapFromFileICM( wide_path( filename ), &pBitmap_ ) );
+        ensure_result( Gdiplus::DllExports::GdipCreateBitmapFromStreamICM( &stream, &pBitmap_ ) );
         BOOST_ASSERT( pBitmap_ );
     }
 
+    // The passed View object must outlive the GpBitmap object (GDI+ uses lazy
+    // evaluation).
     template <class View>
-    explicit gp_bitmap( View & view )
+    explicit gp_image( View & view )
     {
         // http://msdn.microsoft.com/en-us/library/ms536315(VS.85).aspx
         // stride has to be a multiple of 4 bytes
@@ -282,13 +322,13 @@
         BOOST_ASSERT( pBitmap_ );
     }
 
-    ~gp_bitmap()
+    ~gp_image()
     {
         verify_result( Gdiplus::DllExports::GdipDisposeImage( pBitmap_ ) );
     }
 
 public:
-    point2<std::ptrdiff_t> get_dimensions() const
+    point2<std::ptrdiff_t> dimensions() const
     {
         using namespace Gdiplus;
         REAL width, height;
@@ -296,6 +336,15 @@
         return point2<std::ptrdiff_t>( static_cast<std::ptrdiff_t>( width ), static_cast<std::ptrdiff_t>( height ) );
     }
 
+
+    void save_to_png( char    const * const pFilename ) const { save_to( pFilename, png_codec() ); }
+    void save_to_png( wchar_t const * const pFilename ) const { save_to( pFilename, png_codec() ); }
+
+
+
+private: // Private formatted_image_base interface.
+    friend base_t;
+
     Gdiplus::PixelFormat get_format() const
     {
         using namespace Gdiplus;
@@ -304,17 +353,57 @@
         return format;
     }
 
+    image_type_id current_image_type_id() const
+    {
+        switch ( get_format() )
+        {
+            case PixelFormat48bppRGB      :
+            case PixelFormat24bppRGB      :
+                return 0;
+
+            case PixelFormat64bppARGB     :
+            case PixelFormat32bppARGB     :
+                return 1;
+
+            case PixelFormat16bppGrayScale:
+                return 2;
+
+            case PixelFormat16bppRGB565   :
+                return 3;
+
+            case PixelFormat32bppCMYK     :
+                return 4;
+
+            default:
+                BOOST_ASSERT( !"Should not get reached." ); __assume( false );
 
+            case PixelFormat16bppRGB555   :
+
+            case PixelFormat64bppPARGB    :
+            case PixelFormat32bppPARGB    :
+
+            case PixelFormat16bppARGB1555 :
+
+            case PixelFormat32bppRGB      :
+
+            case PixelFormat1bppIndexed   :
+            case PixelFormat4bppIndexed   :
+            case PixelFormat8bppIndexed   :
+                return unsupported_format;
+        }
+    }
+
+public:
     template <typename View>
     void convert_to_prepared_view( View const & view ) const
     {
-        BOOST_STATIC_ASSERT( is_supported<view_gp_format<View>::value>::value );
+        BOOST_STATIC_ASSERT( detail::is_supported<view_gp_format<View>::value>::value );
 
         BOOST_ASSERT( !dimensions_mismatch( view ) );
 
         using namespace Gdiplus;
 
-        if ( is_supported<view_gp_format<View>::value>::value )
+        if ( detail::is_supported<view_gp_format<View>::value>::value )
         {
             PixelFormat const desired_format( view_gp_format<View>::value );
             pre_palettized_conversion<desired_format>( is_indexed<desired_format>::type() );
@@ -326,13 +415,6 @@
         }
     }
 
-    template <typename View>
-    void convert_to_view( View const & view ) const
-    {
-        ensure_dimensions_match();
-        convert_to_prepared_view( view )
-    }
-
     template <typename View, typename CC>
     void convert_to_prepared_view( View const & view, CC const & converter ) const
     {
@@ -349,7 +431,7 @@
         }
         else
         {
-            bool const can_do_in_place( can_do_inplace_transform<typename View::value_type>() );
+            bool const can_do_in_place( can_do_inplace_transform<typename View::value_type>( my_format ) );
             if ( can_do_in_place )
             {
                 bitmapData.PixelFormat = my_format;
@@ -387,30 +469,14 @@
         }
     }
 
-    template <typename View, typename CC>
-    void convert_to_view( View const & view, CC const & converter ) const
-    {
-        ensure_dimensions_match( view );
-        convert_to_prepared_view( view, converter );
-    }
-
-    template <typename View>
-    void copy_to_view( View const & view ) const
-    {
-        ensure_dimensions_match( view );
-        copy_to_prepared_view( view );
-    }
-
     template <typename View>
     void copy_to_prepared_view( View const & view ) const
     {
-        ensure_formats_match<View>();
+        BOOST_ASSERT( !dimensions_mismatch( view ) );
+        BOOST_ASSERT( !formats_mismatch<View>()    );
         convert_to_prepared_view( view );
     }
 
-    void save_to_png( char    const * const pFilename ) const { save_to( pFilename, png_codec() ); }
-    void save_to_png( wchar_t const * const pFilename ) const { save_to( pFilename, png_codec() ); }
-
 private:
     static CLSID const & png_codec()
     {
@@ -446,7 +512,7 @@
         BOOST_STATIC_ASSERT((!is_planar<View>::value /*&& view_is_basic<View>::value*/));
         BOOST_STATIC_ASSERT((boost::is_pointer<typename View::x_iterator>::value));
 
-        BOOST_STATIC_ASSERT( is_supported<view_gp_format<View>::value>::value );
+        BOOST_STATIC_ASSERT( detail::is_supported<view_gp_format<View>::value>::value );
 
         return static_cast<BYTE *>( &gil::at_c<0>( view( 0, 0 ) ) );
     }
@@ -475,9 +541,6 @@
         using namespace Gdiplus;
 
         BitmapData * const pMutableBitmapData( const_cast<BitmapData *>( &bitmapData ) );
-        // It actually performs faster if only ImageLockModeUserInputBuf is
-        // specified, without ImageLockModeRead. Probably does no locking at all
-        // even though this option is not clearly documented.
         GpStatus const load_result
         (
             DllExports::GdipBitmapLockBits
@@ -497,8 +560,8 @@
 
     void copy_to_target( Gdiplus::BitmapData const & bitmapData ) const
     {
-        BOOST_ASSERT( bitmapData.Width       == static_cast<UINT>( get_dimensions().x ) );
-        BOOST_ASSERT( bitmapData.Height      == static_cast<UINT>( get_dimensions().y ) );
+        BOOST_ASSERT( bitmapData.Width       == static_cast<UINT>( dimensions().x ) );
+        BOOST_ASSERT( bitmapData.Height      == static_cast<UINT>( dimensions().y ) );
         //...this need not hold as it can be used to perform GDI+ default
         //internal colour conversion...maybe i'll provide another worker
         //function...
@@ -725,7 +788,7 @@
 
     bool dimensions_mismatch( point2<std::ptrdiff_t> const & other_dimensions ) const
     {
-        return other_dimensions != get_dimensions();
+        return other_dimensions != dimensions();
     }
 
 
@@ -744,7 +807,7 @@
     template <typename View>
     void ensure_dimensions_match( View const & view ) const
     {
-        ensure_dimensions_match( view.get_dimensions() );
+        ensure_dimensions_match( view.dimensions() );
     }
 
     void ensure_dimensions_match( point2<std::ptrdiff_t> const & other_dimensions ) const
@@ -765,6 +828,8 @@
     }
 
 private:
+    friend class gp_view_base;
+
     Gdiplus::GpBitmap * /*const*/ pBitmap_;
 };
 
@@ -773,33 +838,127 @@
 #endif
 
 
+
+////////////////////////////////////////////////////////////////////////////////
+///
+/// \class gp_view_base
+///
+////////////////////////////////////////////////////////////////////////////////
+
+class gp_view_base : noncopyable
+{
+public:
+    ~gp_view_base()
+    {
+        verify_result( Gdiplus::DllExports::GdipBitmapUnlockBits( &bitmap_, &bitmapData_ ) );
+    }
+
+protected:
+    gp_view_base( gp_image & bitmap, unsigned int const lock_mode, gp_image::roi const * const p_roi = 0 )
+        :
+        bitmap_( *bitmap.pBitmap_ )
+    {
+        std::memset( &bitmapData_, 0, sizeof( bitmapData_ ) );
+
+        ensure_result
+        (
+            Gdiplus::DllExports::GdipBitmapLockBits
+            (
+                &bitmap_,
+                p_roi,
+                lock_mode,
+                bitmap.get_format(),
+                &bitmapData_
+            )
+        );
+    }
+
+    template <typename Pixel>
+    typename type_from_x_iterator<Pixel *>::view_t
+    get_typed_view()
+    {
+        //todo assert correct type...
+        interleaved_view<Pixel *>( bitmapData_.Width, bitmapData_.Height, bitmapData_.Scan0, bitmapData_.Stride );
+    }
+
+private:
+    Gdiplus::GpBitmap   & bitmap_    ;
+    Gdiplus::BitmapData   bitmapData_;
+};
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+///
+/// \class gp_view
+///
+////////////////////////////////////////////////////////////////////////////////
+
+template <typename Pixel>
+class gp_view
+    :
+    private gp_view_base,
+    public  type_from_x_iterator<Pixel *>::view_t
+{
+public:
+    gp_view( gp_image & image, gp_image::roi const * const p_roi = 0 )
+        :
+        gp_view_base( image, ImageLockModeRead | ( is_const<Pixel>::value * ImageLockModeWrite ), p_roi ),
+        type_from_x_iterator<Pixel *>::view_t( get_typed_view<Pixel>() )
+    {}
+};
+
+
+//...mhmh...to be seen if necessary...
+//template <typename Pixel>
+//class gp_const_view
+//    :
+//    private gp_view_base,
+//    public  type_from_x_iterator<Pixel const *>::view_t
+//{
+//public:
+//    gp_const_view( gp_image & image, gp_image::roi const * const p_roi = 0 )
+//        :
+//        gp_view_base( image, ImageLockModeRead ),
+//        type_from_x_iterator<Pixel const *>::view_t( get_typed_view<Pixel const>() )
+//    {}
+//};
+
+
+//...mhmh...to be implemented...
+//template <class Impl, class SupportedPixelFormats, class ROI>
+//inline
+//typename formatted_image<Impl, SupportedPixelFormats, ROI>::view_t
+//view( formatted_image<Impl, SupportedPixelFormats, ROI> & img );// { return img._view; }
+
+
 #pragma warning( push )
 #pragma warning( disable : 4355 ) // 'this' used in base member initializer list.
 
-class __declspec( novtable ) gp_memory_bitmap sealed
+class __declspec( novtable ) gp_memory_image sealed
     :
     private MemoryReadStream,
-    public  gp_bitmap
+    public  gp_image
 {
 public:
-    gp_memory_bitmap( memory_chunk_t const & in_memory_image )
+    gp_memory_image( memory_chunk_t const & in_memory_image )
         :
         MemoryReadStream( in_memory_image                 ),
-        gp_bitmap       ( static_cast<IStream &>( *this ) )
+        gp_image        ( static_cast<IStream &>( *this ) )
     {
     }
 };
 
-class __declspec( novtable ) gp_FILE_bitmap sealed
+class __declspec( novtable ) gp_FILE_image sealed
     :
     private FileReadStream,
-    public  gp_bitmap
+    public  gp_image
 {
 public:
-    explicit gp_FILE_bitmap( FILE * const pFile )
+    explicit gp_FILE_image( FILE * const pFile )
         :
         FileReadStream( *pFile                          ),
-        gp_bitmap     ( static_cast<IStream &>( *this ) )
+        gp_image      ( static_cast<IStream &>( *this ) )
     {
     }
 };

Modified: sandbox/gil/boost/gil/extension/io2/gp_private_io.hpp
==============================================================================
--- sandbox/gil/boost/gil/extension/io2/gp_private_io.hpp	(original)
+++ sandbox/gil/boost/gil/extension/io2/gp_private_io.hpp	2010-03-30 12:41:39 EDT (Tue, 30 Mar 2010)
@@ -31,112 +31,112 @@
 {
 //------------------------------------------------------------------------------
 
-inline point2<std::ptrdiff_t> read_dimensions( detail::gp_bitmap const & image ) {
-    return image.get_dimensions();
+inline point2<std::ptrdiff_t> read_dimensions( detail::gp_image const & image ) {
+    return image.dimensions();
 }
 
 inline point2<std::ptrdiff_t> read_dimensions( char const * const filename ) {
-    return read_dimensions( gp_bitmap( filename ) );
+    return read_dimensions( gp_image( filename ) );
 }
 
 
 template <typename View>
-inline void read_view( gp_bitmap const & image, View const & view ) {
+inline void read_view( gp_image const & image, View const & view ) {
     image.copy_to_view( view );
 }
 
 template <typename View>
 inline void read_view( char const * const filename, View const & view ) {
-    read_view( gp_bitmap( filename ), view );
+    read_view( gp_image( filename ), view );
 }
 
 
 template <typename Image>
-inline void read_image( gp_bitmap const & gp_image, Image & gil_image ) {
+inline void read_image( gp_image const & gp_image, Image & gil_image ) {
     gil_image.recreate( gp_image.get_dimensions(), sizeof( Gdiplus::ARGB ) );
     gp_image.copy_to_prepared_view( view( gil_image ) );
 }
 
 template <typename Image>
 inline void read_image(const char* filename,Image& im) {
-    read_image( gp_bitmap( filename ), im );
+    read_image( gp_image( filename ), im );
 }
 
 template <typename Image>
 inline void read_image( wchar_t const * const filename, Image & im ) {
-    read_image( gp_bitmap( filename ), im );
+    read_image( gp_image( filename ), im );
 }
 
 
 template <typename View,typename CC>
-inline void read_and_convert_view( gp_bitmap const & image, View const & view, CC cc ) {
+inline void read_and_convert_view( gp_image const & image, View const & view, CC cc ) {
     image.convert_to_view( view, cc );
 }
 
 template <typename View,typename CC>
 inline void read_and_convert_view( char const * const filename, View const & view, CC cc ) {
-    read_and_convert_view( gp_bitmap( filename ), view, cc );
+    read_and_convert_view( gp_image( filename ), view, cc );
 }
 
 
 template <typename View>
-inline void read_and_convert_view( gp_bitmap const & image, View const & view ) {
+inline void read_and_convert_view( gp_image const & image, View const & view ) {
     image.convert_to_view( view );
 }
 
 template <typename View>
 inline void read_and_convert_view( const char* filename, const View& view ) {
-    read_and_convert_view( gp_bitmap( filename ), view );
+    read_and_convert_view( gp_image( filename ), view );
 }
 
 
 template <typename Image,typename CC>
-inline void read_and_convert_image( gp_bitmap const & gp_image, Image & gil_image, CC cc ) {
+inline void read_and_convert_image( gp_image const & gp_image, Image & gil_image, CC cc ) {
     gil_image.recreate( gp_image.get_dimensions(), sizeof( Gdiplus::ARGB ) );
     gp_image.convert_to_prepared_view( view( gil_image ), cc );
 }
 
 template <typename Image,typename CC>
 inline void read_and_convert_image(const char* filename,Image& im,CC cc) {
-    read_and_convert_image( gp_bitmap( filename ), im, cc );
+    read_and_convert_image( gp_image( filename ), im, cc );
 }
 
 template <typename Image,typename CC>
 inline void read_and_convert_image( wchar_t const * const filename, Image & im, CC const & cc ) {
-    read_and_convert_image( gp_bitmap( filename ), im, cc );
+    read_and_convert_image( gp_image( filename ), im, cc );
 }
 
 
 template <typename Image>
-inline void read_and_convert_image( gp_bitmap const & gp_image, Image & gil_image ) {
-    gil_image.recreate( gp_image.get_dimensions(), sizeof( Gdiplus::ARGB ) );
+inline void read_and_convert_image( gp_image const & gp_image, Image & gil_image ) {
+    gil_image.recreate( gp_image.dimensions(), sizeof( Gdiplus::ARGB ) );
     gp_image.convert_to_prepared_view( view( gil_image ) );
 }
 
 template <typename Image>
 inline void read_and_convert_image(const char* filename,Image& im) {
-    read_and_convert_image( gp_bitmap( filename ), im );
+    read_and_convert_image( gp_image( filename ), im );
 }
 
 template <typename Image>
 inline void read_and_convert_image( wchar_t const * const filename, Image & im ) {
-    read_and_convert_image( gp_bitmap( filename ), im );
+    read_and_convert_image( gp_image( filename ), im );
 }
 
 template <typename Image>
 inline void read_and_convert_image( FILE * pFile, Image & im ) {
-    read_and_convert_image( gp_FILE_bitmap( pFile ), im );
+    read_and_convert_image( gp_FILE_image( pFile ), im );
 }
 
 template <typename Image>
 inline void read_and_convert_image( memory_chunk_t const & in_memory_image, Image & im ) {
-    read_and_convert_image( gp_memory_bitmap( in_memory_image ), im );
+    read_and_convert_image( gp_memory_image( in_memory_image ), im );
 }
 
 
 template <typename View>
 inline void png_write_view(const char* filename,const View& view) {
-    detail::gp_bitmap const m( view );
+    detail::gp_image const m( view );
     m.save_to_png( filename );
 }