[Boost-commit] svn:boost r64081 - sandbox/gil/boost/gil/extension/io2

Subject: [Boost-commit] svn:boost r64081 - sandbox/gil/boost/gil/extension/io2
From: dsaritz_at_[hidden]
Date: 2010-07-17 05:27:22

Author: psiha
Date: 2010-07-17 05:27:20 EDT (Sat, 17 Jul 2010)
New Revision: 64081
URL: http://svn.boost.org/trac/boost/changeset/64081

Log:
Moved the offset classes to the public namespace.
Moved a few more utility functions to the formatted_image_base class.
Added the formatted_image<>::image_id_finder functor and used it to implement the new formatted_image<>::image_format_id() member function.
Added planar image support to the formatted_image<>::in_place_converter_t functor.

Minor other refactoring and stylistic changes.
Text files modified: 
   sandbox/gil/boost/gil/extension/io2/formatted_image.hpp |   340 ++++++++++++++++++++++++++++----------- 
   1 files changed, 239 insertions(+), 101 deletions(-)

Modified: sandbox/gil/boost/gil/extension/io2/formatted_image.hpp
==============================================================================
--- sandbox/gil/boost/gil/extension/io2/formatted_image.hpp	(original)
+++ sandbox/gil/boost/gil/extension/io2/formatted_image.hpp	2010-07-17 05:27:20 EDT (Sat, 17 Jul 2010)
@@ -26,6 +26,7 @@
 
 #include <boost/gil/extension/dynamic_image/any_image.hpp>
 
+#include <boost/compressed_pair.hpp>
 #ifdef _DEBUG
 #include <boost/detail/endian.hpp>
 #endif // _DEBUG
@@ -101,7 +102,7 @@
         typedef detail::channel_convert_to_unsigned  <SrcChannelV> to_unsigned;
         typedef detail::channel_convert_from_unsigned<DstChannelV> from_unsigned;
 
-        if ( is_unsigned<SrcChannelV>::value )
+        if ( std::tr1::is_unsigned<SrcChannelV>::value )
         {
             SrcChannelV  const source_max( detail::unsigned_integral_max_value<SrcChannelV>::value );
             unsigned int const tmp       ( ( static_cast<unsigned short>( src ) << DestPackedNumBits ) - src );
@@ -135,13 +136,107 @@
 #endif
 
 
+////////////////////////////////////////////////////////////////////////////////
+///
+/// \class offset_view_t
+/// \todo document properly...
+///
+////////////////////////////////////////////////////////////////////////////////
+
+template <class View, typename Offset>
+class offset_view_t
+{
+public:
+    typedef View   view_t  ;
+    typedef Offset offset_t;
+
+public:
+    offset_view_t( View const & view, Offset const & offset ) : view_( view ), offset_( offset ) {}
+
+    typename View::point_t dimensions() const
+    {
+        return offset_dimensions( original_view().dimensions(), offset() );
+    }
+
+    View   const & original_view() const { return view_  ; }
+    Offset const & offset       () const { return offset_; }
+
+private:
+    static typename View::point_t offset_dimensions
+    (
+        typename View::point_t                   view_dimensions,
+        typename View::point_t::value_type const offset
+    )
+    {
+        //return typename View::point_t( view_dimensions.x, view_dimensions.y + offset );
+        view_dimensions.y += offset;
+        return view_dimensions;
+    }
+
+    static typename View::point_t offset_dimensions
+    (
+        typename View::point_t         view_dimensions,
+        typename View::point_t const & offset
+    )
+    {
+        return view_dimensions += offset;
+    }
+
+private:
+    View                                     const & view_  ;
+    typename call_traits<Offset>::param_type         offset_;
+};
+
+
+template <class View, typename Offset>
+offset_view_t<View, Offset> offset_view( View const & view, Offset const & offset ) { return offset_view_t<View, Offset>( view, offset ); }
+
+
 namespace detail
 {
 //------------------------------------------------------------------------------
 
+#ifndef _UNICODE
+    typedef char    TCHAR;
+#else
+    typedef wchar_t TCHAR;
+#endif
 typedef iterator_range<TCHAR const *> string_chunk_t;
 
 
+template <class View, typename Offset>
+View const & original_view( offset_view_t<View, Offset> const & offset_view ) { return offset_view.original_view(); }
+
+template <class View>
+View const & original_view( View const & view ) { return view; }
+
+template <typename Offset, class View>
+Offset const & get_offset( offset_view_t<View, Offset> const & offset_view ) { return offset_view.offset(); }
+
+template <typename Offset, class View>
+Offset get_offset( View const & ) { return Offset(); }
+
+
+template <class NewView, class View, typename Offset>
+offset_view_t<NewView, Offset> offset_new_view( NewView const & new_view, offset_view_t<View, Offset> const & offset_view )
+{
+    return offset_view_t<NewView, Offset>( new_view, offset_view.offset_ );
+}
+
+template <class NewView, class View>
+NewView const & offset_new_view( NewView const & new_view, View const & ) { return new_view; }
+
+
+template <typename View>
+struct get_original_view_t;
+
+template <typename Locator>
+struct get_original_view_t<image_view<Locator> > { typedef image_view<Locator> type; };
+
+template <typename View, typename Offset>
+struct get_original_view_t<offset_view_t<View, Offset> > { typedef View type; };
+
+
 ////////////////////////////////////////////////////////////////////////////////
 ///
 /// \class formatted_image_base
@@ -165,6 +260,13 @@
         return dimensions_mismatch( mine, view.dimensions() );
     }
 
+    template <class View, typename Offset>
+    static bool dimensions_mismatch( dimensions_t const & mine, offset_view_t<View, Offset> const & offset_view )
+    {
+        dimensions_t const other( offset_view.dimensions() );
+        return !( ( mine.x >= other.x ) && ( mine.y >= other.y ) );
+    }
+
     static void do_ensure_dimensions_match( dimensions_t const & mine, dimensions_t const & other )
     {
         io_error_if( dimensions_mismatch( mine, other ), "input view size does not match source image size" );
@@ -176,6 +278,12 @@
         do_ensure_dimensions_match( mine, view.dimensions() );
     }
 
+    template <class View, typename Offset>
+    static void do_ensure_dimensions_match( dimensions_t const & mine, offset_view_t<View, Offset> const & offset_view )
+    {
+        io_error_if( dimensions_mismatch( mine, offset_view ), "input view size does not match source image size" );
+    }
+
     static void do_ensure_formats_match( bool const formats_mismatch )
     {
         io_error_if( formats_mismatch, "input view format does not match source image format" );
@@ -266,66 +374,6 @@
 };
 
 
-////////////////////////////////////////////////////////////////////////////////
-///
-/// \class offset_view_t
-/// \todo document properly...
-///
-////////////////////////////////////////////////////////////////////////////////
-
-template <class View, typename Offset>
-class offset_view_t
-{
-public:
-    offset_view_t( View const & view, Offset const & offset ) : view_( view ), offset_( offset ) {}
-
-    typename View::point_t dimensions() const
-    {
-        return offset_dimensions( offset_ );
-    }
-
-    View   const & original_view() const { return view_  ; }
-    Offset const & offset       () const { return offset_; }
-
-private:
-    typename View::point_t offset_dimensions( typename View::point_t::value_type const offset ) const
-    {
-        typename View::point_t view_dimensions( view_.dimensions() );
-        return view_dimensions += typename View::point_t( 0, offset );
-    }
-
-    typename View::point_t  offset_dimensions( typename View::point_t const & offset ) const
-    {
-        typename View::point_t view_dimensions( view_.dimensions() );
-        return view_dimensions += offset;
-    }
-
-private:
-    View                                     const & view_  ;
-    typename call_traits<Offset>::param_type         offset_;
-};
-
-template <class View, typename Offset>
-View const & original_view( offset_view_t<View, Offset> const & offset_view ) { return offset_view.original_view(); }
-
-template <class View>
-View const & original_view( View const & view ) { return view; }
-
-template <typename Offset, class View>
-Offset const & get_offset( offset_view_t<View, Offset> const & offset_view ) { return offset_view.offset(); }
-
-template <typename Offset, class View>
-Offset get_offset( View const & ) { return Offset(); }
-
-
-template <class NewView, class View, typename Offset>
-offset_view_t<NewView, Offset> offset_new_view( NewView const & new_view, offset_view_t<View, Offset> const & offset_view )
-{
-    return offset_view_t<NewView, Offset>( new_view, offset_view.offset_ );
-}
-
-template <class NewView, class View>
-NewView const & offset_new_view( NewView const & new_view, View const & ) { return new_view; }
 
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -410,6 +458,28 @@
 
     typedef mpl::range_c<std::size_t, 0, mpl::size<supported_pixel_formats>::value> valid_type_id_range_t;
 
+    struct image_id_finder
+    {
+        image_id_finder( format_t const format ) : format_( format ), image_id_( static_cast<unsigned int>( -1 ) ) {}
+
+        template <typename ImageIndex>
+        void operator()( ImageIndex )
+        {
+            format_t const image_format
+            (
+                formatted_image_traits<Impl>::view_to_native_format::apply<typename mpl::at<supported_pixel_formats, ImageIndex>::type::view_t>::value
+            );
+            if ( image_format == this->format_ )
+            {
+                BOOST_ASSERT( image_id_ == -1 );
+                image_id_ = ImageIndex::value;
+            }
+        }
+
+        format_t /*const*/ format_;
+        unsigned int       image_id_;
+    };
+
 private:
     Impl       & impl()       { return static_cast<Impl       &>( *this ); }
     Impl const & impl() const { return static_cast<Impl const &>( *this ); }
@@ -418,7 +488,7 @@
     template <typename View>
     bool dimensions_mismatch( View const & view ) const
     {
-        return dimensions_mismatch( view.dimensions() );
+        return formatted_image_base::dimensions_mismatch( impl().dimensions(), view );
     }
 
     bool dimensions_mismatch( dimensions_t const & other_dimensions ) const
@@ -429,7 +499,7 @@
     template <class View>
     void do_ensure_dimensions_match( View const & view ) const
     {
-        formatted_image_base::do_ensure_dimensions_match( impl().dimensions(), view.dimensions() );
+        formatted_image_base::do_ensure_dimensions_match( impl().dimensions(), view );
     }
 
     template <typename View>
@@ -455,17 +525,29 @@
     template <typename View>
     bool can_do_inplace_transform( typename formatted_image_traits<Impl>::format_t const my_format ) const
     {
-        return ( Impl::format_size( my_format ) == sizeof( typename View::value_type ) );
+        return ( Impl::format_size( my_format ) == memunit_step( get_original_view_t<View>::type::x_iterator() )/*sizeof( typename get_original_view_t<View>::type::value_type )*/ );
+    }
+
+    // A generic implementation...impl classes are encouraged to provide more
+    // efficient overrides...
+    static image_type_id image_format_id( format_t const closest_gil_supported_format )
+    {
+        // This (linear search) will be transformed to a switch...
+        image_id_finder finder( closest_gil_supported_format );
+        mpl::for_each<valid_type_id_range_t>( ref( finder ) );
+        BOOST_ASSERT( finder.image_id_ != -1 );
+        return finder.image_id_;
     }
 
 public: // Views...
     template <typename View>
-    void copy_to( View & view, assert_dimensions_match, assert_formats_match ) const
+    void copy_to( View const & view, assert_dimensions_match, assert_formats_match ) const
     {
+        BOOST_STATIC_ASSERT( View::value_type::is_mutable );
         BOOST_STATIC_ASSERT( formatted_image_traits<Impl>::is_supported<View>::value );
         BOOST_ASSERT( !impl().dimensions_mismatch( view ) );
         BOOST_ASSERT( !impl().formats_mismatch<View>()    );
-        impl().raw_convert_to_prepared_view
+        impl().raw_copy_to_prepared_view
         (
             formatted_image_traits<Impl>::view_data_t
             (
@@ -476,57 +558,55 @@
     }
 
     template <typename View>
-    void copy_to( View & view, assert_dimensions_match, ensure_formats_match ) const
+    void copy_to( View const & view, assert_dimensions_match, ensure_formats_match ) const
     {
         impl().do_ensure_formats_match<View>();
         impl().copy_to( view, assert_dimensions_match(), assert_formats_match() );
     }
 
     template <typename View>
-    void copy_to( View & view, ensure_dimensions_match, assert_formats_match ) const
+    void copy_to( View const & view, ensure_dimensions_match, assert_formats_match ) const
     {
         impl().do_ensure_dimensions_match( view );
         impl().copy_to( view, assert_dimensions_match(), assert_formats_match() );
     }
 
     template <typename View>
-    void copy_to( View & view, ensure_dimensions_match, ensure_formats_match ) const
+    void copy_to( View const & view, ensure_dimensions_match, ensure_formats_match ) const
     {
-        impl().do_ensure_formats_match<View>();
         impl().do_ensure_dimensions_match( view );
         impl().copy_to( view, assert_dimensions_match(), ensure_formats_match() );
     }
 
     template <typename View>
-    void copy_to( View & view, ensure_dimensions_match, synchronize_formats ) const
+    void copy_to( View const & view, ensure_dimensions_match, synchronize_formats ) const
     {
         impl().do_ensure_dimensions_match( view );
         impl().copy_to( view, assert_dimensions_match(), synchronize_formats() );
     }
 
     template <typename View>
-    void copy_to( View & view, assert_dimensions_match, synchronize_formats ) const
+    void copy_to( View const & view, assert_dimensions_match, synchronize_formats ) const
     {
         BOOST_ASSERT( !impl().dimensions_mismatch( view ) );
-        impl().raw_convert_to_prepared_view
+        bool const can_use_raw
         (
-            formatted_image_traits<Impl>::view_data_t
-            (
-                original_view       ( view ),
-                get_offset<offset_t>( view )
-            )
+            formatted_image_traits<Impl>::is_supported<View>::value &&
+            formatted_image_traits<Impl>::builtin_conversion
         );
+        default_convert_to_worker( view, mpl::bool_<can_use_raw>() );
     }
 
+
     template <typename FormatConverter, typename View>
-    void copy_to( View & view, ensure_dimensions_match, FormatConverter const & format_converter ) const
+    void copy_to( View const & view, ensure_dimensions_match, FormatConverter const & format_converter ) const
     {
         impl().do_ensure_dimensions_match( view );
         impl().copy_to( view, assert_dimensions_match(), format_converter );
     }
 
     template <typename FormatConverter, typename View>
-    void copy_to( View & view, assert_dimensions_match, FormatConverter const & format_converter ) const
+    void copy_to( View const & view, assert_dimensions_match, FormatConverter const & format_converter ) const
     {
         BOOST_ASSERT( !impl().dimensions_mismatch( view ) );
         impl().convert_to_prepared_view( view, format_converter );
@@ -580,63 +660,102 @@
 
 private:
     template <class View, typename CC>
-    struct in_place_converter_t
+    class in_place_converter_t
     {
+    public:
         typedef void result_type;
 
-        in_place_converter_t( CC const & cc, View const & view ) : cc_( cc ), view_( view ) {}
+        in_place_converter_t( CC const & cc, View const & view ) : members_( cc, view ) {}
 
         template <std::size_t index>
-        void operator()( mpl::integral_c<std::size_t, index> const & ) const
+        void operator()( mpl::integral_c<std::size_t, index> ) const
         {
             typedef typename mpl::at_c<supported_pixel_formats, index>::type::view_t view_t;
-            BOOST_STATIC_ASSERT( sizeof( view_t ) == sizeof( View ) );
-            for_each_pixel( *gil_reinterpret_cast_c<view_t const *>( &view_ ), *this );
+            BOOST_ASSERT( is_planar<View>::value == is_planar<view_t>::value ); //zzz...make this a static assert...
+            if ( is_planar<View>::value )
+            {
+                for ( unsigned int plane( 0 ); plane < num_channels<View>::value; ++plane )
+                {
+                    BOOST_ASSERT( sizeof( view_t ) == sizeof( View ) ); //zzz...make this a static assert...
+                    for_each_pixel( nth_channel_view( *gil_reinterpret_cast_c<view_t const *>( &view() ), plane ), *this );
+                }
+            }
+            else
+            {
+                BOOST_ASSERT( sizeof( view_t ) == sizeof( View ) ); //zzz...make this a static assert...
+                for_each_pixel( *gil_reinterpret_cast_c<view_t const *>( &view() ), *this );
+            }
         }
 
         template <typename SrcP>
         typename enable_if<is_pixel<SrcP>>::type
         operator()( SrcP & srcP )
         {
-            BOOST_ASSERT( sizeof( SrcP ) == sizeof( typename View::value_type ) );
-            cc_( srcP, *gil_reinterpret_cast<typename View::value_type *>( &srcP ) );
+            convert_aux( srcP, is_planar<View>() );
         }
 
         void operator=( in_place_converter_t const & other )
         {
-            BOOST_ASSERT( this->view_ == other.view_ );
-            this->cc_ = other.cc_;
+            BOOST_ASSERT( this->view() == other.view() );
+            this->cc() = other.cc();
+        }
+
+    private:
+        CC         & cc  ()       { return members_.first (); }
+        CC   const & cc  () const { return members_.first (); }
+        View const & view() const { return members_.second(); }
+
+        template <typename SrcP>
+        void convert_aux( SrcP & srcP, mpl::true_ /*is planar*/ )
+        {
+            typedef typename nth_channel_view_type<View>::type::value_type DstP;
+            BOOST_ASSERT( sizeof( SrcP ) == sizeof( DstP ) ); //zzz...make this a static assert...
+            cc()( srcP, *const_cast<DstP *>( gil_reinterpret_cast_c<DstP const *>( &srcP ) ) );
+        }
+
+        template <typename SrcP>
+        void convert_aux( SrcP & srcP, mpl::false_ /*is not planar*/ )
+        {
+            typedef typename View::value_type DstP;
+            BOOST_ASSERT( sizeof( SrcP ) == sizeof( DstP ) ); //zzz...make this a static assert...
+            cc()( srcP, *const_cast<DstP *>( gil_reinterpret_cast_c<DstP const *>( &srcP ) ) );
         }
 
-        CC cc_;
-        View const & view_;
+    private:
+        compressed_pair<CC, View const &> members_;
     };
 
     template <class View, typename CC>
-    struct generic_converter_t
+    class generic_converter_t
     {
+    public:
         typedef void result_type;
 
         generic_converter_t( Impl const & impl, CC const & cc, View const & view )
-            : impl_( impl ), cc_( cc ), view_( view ) {}
+            : impl_( impl ), cc_view_( cc, view ) {}
 
         template <std::size_t index>
         void operator()( mpl::integral_c<std::size_t, index> const & ) const
         {
             typedef typename mpl::at_c<supported_pixel_formats, index>::type::view_t my_view_t;
-            impl_.generic_convert_to_prepared_view<my_view_t>( view_, cc_ );
+            impl_.generic_convert_to_prepared_view<my_view_t>( view(), cc() );
         }
 
         void operator=( generic_converter_t const & other )
         {
             BOOST_ASSERT( this->impl_ == other.impl_ );
             BOOST_ASSERT( this->view_ == other.view_ );
-            this->cc_ = other.cc_;
+            this->cc() = other.cc();
         }
 
-        Impl const & impl_;
-        CC           cc_  ;
-        View const & view_;
+    private:
+        CC         & cc  ()       { return cc_view_.first (); }
+        CC   const & cc  () const { return cc_view_.first (); }
+        View const & view() const { return cc_view_.second(); }
+
+    private:
+        Impl                              const & impl_   ;
+        compressed_pair<CC, View const &>         cc_view_;
     };
 
     template <class TargetView, class CC>
@@ -671,7 +790,7 @@
             converter,
             mpl::bool_
             <
-                is_plain_in_memory_view<View>::value &&
+                is_plain_in_memory_view<typename get_original_view_t<View>::type>::value &&
                 formatted_image_traits<Impl>::is_supported<View>::value
             >()
         );
@@ -684,9 +803,9 @@
         unsigned int const current_image_format_id( impl().image_format_id( my_format )   );
         if ( can_do_inplace_transform<View>( my_format ) )
         {
-            Impl::view_data_t view_data( original_view( view ), get_offset<offset_t>( view ) );
+            typename formatted_image_traits<Impl>::view_data_t view_data( original_view( view ), get_offset<offset_t>( view ) );
             view_data.set_format( my_format );
-            impl().copy_to_prepared_view( view_data );
+            impl().raw_copy_to_prepared_view( view_data );
             in_place_transform( current_image_format_id, original_view( view ), converter );
         }
         else
@@ -700,6 +819,25 @@
     {
         generic_transform( Impl::image_format_id( impl().closest_gil_supported_format() ), view, converter );
     }
+
+    template <typename View>
+    void default_convert_to_worker( View const & view, mpl::true_ /*can use raw*/ ) const
+    {
+        impl().raw_convert_to_prepared_view
+        (
+            formatted_image_traits<Impl>::view_data_t
+            (
+                original_view       ( view ),
+                get_offset<offset_t>( view )
+            )
+        );
+    }
+
+    template <typename View>
+    void default_convert_to_worker( View const & view, mpl::false_ /*cannot use raw*/ ) const
+    {
+        impl().convert_to_prepared_view( view, default_color_converter() );
+    }
 };