core/image_view_factory.hpp Go to the documentation of this file. /* Copyright 2005-2006 Adobe Systems Incorporated Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt or a copy at http://opensource.adobe.com/licenses.html) */ /*************************************************************************************************/ #ifndef GIL_IMAGE_VIEW_FACTORY_HPP #define GIL_IMAGE_VIEW_FACTORY_HPP #include <cassert> #include <cstddef> #include "gil_config.hpp" #include "metafunctions.hpp" #include "gray.hpp" ADOBE_GIL_NAMESPACE_BEGIN struct default_color_converter; template <typename Iterator> inline typename type_from_x_iterator<Iterator>::view_t interleaved_view(int width, int height, Iterator pixels, std::ptrdiff_t rowsize_in_bytes) { typedef typename type_from_x_iterator<Iterator>::view_t RVIEW; return RVIEW(width, height, typename RVIEW::locator(pixels, rowsize_in_bytes)); } template <typename SrcConstRefP, typename DstP, typename CC=default_color_converter > // const_reference to the source pixel and destination pixel value class color_convert_deref_fn { private: CC _cc; // color-converter public: typedef color_convert_deref_fn const_t; typedef DstP value_type; typedef value_type reference; // read-only dereferencing typedef const value_type& const_reference; typedef SrcConstRefP argument_type; typedef reference result_type; BOOST_STATIC_CONSTANT(bool, is_mutable=false); color_convert_deref_fn() {} color_convert_deref_fn(CC cc_in) : _cc(cc_in) {} result_type operator()(argument_type srcP) const { result_type dstP; _cc(srcP,dstP); return dstP; } }; namespace detail { // Add color converter upon dereferencing template <typename SrcView, typename CC, typename DstP, typename SrcP> struct _color_converted_view_type { private: typedef color_convert_deref_fn<typename SrcView::const_t::reference,DstP,CC> deref_t; typedef typename SrcView::template add_deref<deref_t> add_ref_t; public: typedef typename add_ref_t::type type; static type make(const SrcView& sv,CC cc) {return add_ref_t::make(sv,deref_t(cc));} }; // If the Src view has the same pixel type as the target, there is no need for color conversion template <typename SrcView, typename CC, typename DstP> struct _color_converted_view_type<SrcView,CC,DstP,DstP> { typedef SrcView type; static type make(const SrcView& sv,CC) {return sv;} }; } // namespace detail template <typename SrcView, typename DstP, typename CC=default_color_converter> struct color_converted_view_type : public detail::_color_converted_view_type<SrcView, CC, DstP, typename SrcView::pixel_t> { GIL_CLASS_REQUIRE(SrcView, GIL, ImageViewConcept); GIL_CLASS_REQUIRE(DstP, GIL, MutablePixelConcept);//why does it have to MutablePixelConcept??? }; template <typename DstP, typename View, typename CC> inline typename color_converted_view_type<View,DstP,CC>::type color_converted_view(const View& src,CC cc) { return color_converted_view_type<View,DstP,CC>::make(src,cc); } template <typename DstP, typename View> inline typename color_converted_view_type<View,DstP>::type color_converted_view(const View& src) { return color_converted_view<DstP>(src,default_color_converter()); } template <typename View> inline typename View::dynamic_y_step_t flipped_up_down_view(const View& src) { typedef typename View::dynamic_y_step_t RVIEW; return RVIEW(src.dimensions(),typename RVIEW::xy_locator(src.xy_at(0,src.height()-1),-1)); } template <typename View> inline typename View::dynamic_x_step_t flipped_left_right_view(const View& src) { typedef typename View::dynamic_x_step_t RVIEW; return RVIEW(src.dimensions(),typename RVIEW::xy_locator(src.xy_at(src.width()-1,0),-1,1)); } template <typename View> inline typename View::dynamic_xy_step_transposed_t transposed_view(const View& src) { typedef typename View::dynamic_xy_step_transposed_t RVIEW; return RVIEW(src.height(),src.width(),typename RVIEW::xy_locator(src.xy_at(0,0),1,1,true)); } template <typename View> inline typename View::dynamic_xy_step_transposed_t rotated90cw_view(const View& src) { typedef typename View::dynamic_xy_step_transposed_t RVIEW; return RVIEW(src.height(),src.width(),typename RVIEW::xy_locator(src.xy_at(0,src.height()-1),-1,1,true)); } template <typename View> inline typename View::dynamic_xy_step_transposed_t rotated90ccw_view(const View& src) { typedef typename View::dynamic_xy_step_transposed_t RVIEW; return RVIEW(src.height(),src.width(),typename RVIEW::xy_locator(src.xy_at(src.width()-1,0),1,-1,true)); } template <typename View> inline typename View::dynamic_xy_step_t rotated180_view(const View& src) { typedef typename View::dynamic_xy_step_t RVIEW; return RVIEW(src.dimensions(),typename RVIEW::xy_locator(src.xy_at(src.width()-1,src.height()-1),-1,-1)); } template <typename View> inline View subimage_view(const View& src, const typename View::point_t& topleft, const typename View::point_t& dimensions) { return View(dimensions,src.xy_at(topleft)); } template <typename View> inline View subimage_view(const View& src, int xMin, int yMin, int width, int height) { return View(width,height,src.xy_at(xMin,yMin)); } template <typename View> inline typename View::dynamic_xy_step_t subsampled_view(const View& src, typename View::coord_t xStep, typename View::coord_t yStep) { assert(xStep>0 && yStep>0); typedef typename View::dynamic_xy_step_t RVIEW; return RVIEW((src.width()+(xStep-1))/xStep,(src.height()+(yStep-1))/yStep, typename RVIEW::xy_locator(src.xy_at(0,0),xStep,yStep)); } template <typename View> inline typename View::dynamic_xy_step_t subsampled_view(const View& src, const typename View::point_t& step) { return subsampled_view(src,step.x,step.y); } namespace detail { template <typename View, bool AreChannelsTogether> struct __nth_channel_view_basic; // nth_channel_view when the channels are not adjacent in memory. This can happen for multi-channel interleaved images // or images with a step template <typename View> struct __nth_channel_view_basic<View,false> { typedef typename view_type<typename View::channel_t, gray_t, false, true, view_is_mutable<View>::value>::type type; static type make(const View& src, int n) { typedef typename type::xy_locator locator_t; typedef typename type::x_iterator x_iterator_t; typedef typename pixel_iterator_traits<x_iterator_t>::base_t x_iterator_base_t; x_iterator_t sit(x_iterator_base_t(&(src(0,0)[n])),src.pixels().pix_bytestep()); return type(src.dimensions(),locator_t(sit, src.pixels().row_bytes())); } }; // nth_channel_view when the channels are together in memory (true for simple grayscale or planar images) template <typename View> struct __nth_channel_view_basic<View,true> { typedef typename view_type<typename View::channel_t, gray_t, false, false, view_is_mutable<View>::value>::type type; static type make(const View& src, int n) { typedef typename type::x_iterator x_iterator_t; return interleaved_view(src.width(),src.height(),(x_iterator_t)&(src(0,0)[n]), src.pixels().row_bytes()); } }; template <typename View, bool IsBasic> struct __nth_channel_view; // For basic (memory-based) views dispatch to __nth_channel_view_basic template <typename View> struct __nth_channel_view<View,true> { private: typedef typename View::x_iterator src_x_iterator; // Determines whether the channels of a given pixel iterator are adjacent in memory. // Planar and grayscale iterators have channels adjacent in memory, whereas multi-channel interleaved and iterators with non-fundamental step do not. BOOST_STATIC_CONSTANT(bool, adjacent= !iterator_is_step<src_x_iterator>::value && (pixel_iterator_traits<src_x_iterator>::is_planar || pixel_iterator_traits<src_x_iterator>::color_space_t::num_channels==1)); public: typedef typename __nth_channel_view_basic<View,adjacent>::type type; static type make(const View& src, int n) { return __nth_channel_view_basic<View,adjacent>::make(src,n); } }; template <typename SrcP> // SrcP models PixelConcept (could be pixel value or const/non-const reference) // Examples: pixel<T,C>, pixel<T,C>&, const pixel<T,C>&, planar_ref<T&,C>, planar_ref<const T&,C> struct nth_channel_deref_fn { BOOST_STATIC_CONSTANT(bool, is_mutable=is_pixel_reference<SrcP>::value && pixel_reference_is_mutable<SrcP>::value); private: typedef typename pixel_traits<SrcP>::channel_t channel_t; typedef typename pixel_traits<SrcP>::const_reference const_ref_t; typedef typename pixel_reference_type<channel_t,gray_t,false,is_mutable>::type ref_t; public: typedef nth_channel_deref_fn<const_ref_t> const_t; typedef pixel<channel_t,gray_t> value_type; typedef typename pixel_reference_type<channel_t,gray_t,false,false>::type const_reference; typedef SrcP argument_type; typedef typename boost::mpl::if_c<is_mutable, ref_t, value_type>::type reference; typedef reference result_type; nth_channel_deref_fn(int n=0) : _n(n) {} template <typename P> nth_channel_deref_fn(const nth_channel_deref_fn<P>& d) : _n(d._n) {} int _n; // the channel to use result_type operator()(argument_type srcP) const { return result_type(srcP[_n]); } }; template <typename View> struct __nth_channel_view<View,false> { private: typedef nth_channel_deref_fn<typename View::reference> deref_t; typedef typename View::template add_deref<deref_t> AD; public: typedef typename AD::type type; static type make(const View& src, int n) { return AD::make(src, deref_t(n)); } }; } template <typename View> struct nth_channel_view_type { private: GIL_CLASS_REQUIRE(View, GIL, ImageViewConcept); typedef detail::__nth_channel_view<View,view_is_basic<View>::value> VB; public: typedef typename VB::type type; static type make(const View& src, int n) { return VB::make(src,n); } }; template <typename View> typename nth_channel_view_type<View>::type nth_channel_view(const View& src, int n) { return nth_channel_view_type<View>::make(src,n); } ADOBE_GIL_NAMESPACE_END #endif

• Company | 
• Online Privacy Policy | 
• Terms of Use | 
• Contact Us | 
• Accessibility | 
• Report Piracy | 
• Permissions & Trademarks | 
• Product License Agreements | 
• Send Feedback

Copyright © 2006 Adobe Systems Incorporated.

Use of this website signifies your agreement to the Terms of Use and Online Privacy Policy.

Search powered by Google