13 #ifndef GIL_ALGORITHM_HPP
14 #define GIL_ALGORITHM_HPP
24 #include <boost/config.hpp>
25 #include <boost/utility/enable_if.hpp>
26 #include <boost/mpl/and.hpp>
27 #include <boost/mpl/or.hpp>
50 namespace boost {
namespace gil {
52 template <
typename ChannelPtr,
typename ColorSpace>
54 template <
typename Iterator>
56 template <
typename StepIterator>
99 template <
typename Derived,
typename Result=
void>
101 typedef Result result_type;
103 template <
typename V1,
typename V2> BOOST_FORCEINLINE
104 result_type operator()(
const std::pair<const V1*,const V2*>& p)
const {
108 template <
typename V1,
typename V2> BOOST_FORCEINLINE
109 result_type operator()(
const V1& v1,
const V2& v2)
const {
113 result_type operator()(
const error_t&)
const {
throw std::bad_cast(); }
117 template <
typename V1,
typename V2>
118 BOOST_FORCEINLINE result_type apply(
const V1& v1,
const V2& v2, mpl::false_)
const {
119 return ((
const Derived*)
this)->apply_incompatible(v1,v2);
123 template <
typename V1,
typename V2>
124 BOOST_FORCEINLINE result_type apply(
const V1& v1,
const V2& v2, mpl::true_)
const {
125 return ((
const Derived*)
this)->apply_compatible(v1,v2);
129 template <
typename V1,
typename V2>
130 BOOST_FORCEINLINE result_type apply_incompatible(
const V1&,
const V2&)
const {
131 throw std::bad_cast();
149 template<
typename T,
typename Cs>
158 template<
typename T,
typename Cs>
166 namespace boost {
namespace gil {
168 template <
typename I,
typename O>
struct copy_fn {
169 BOOST_FORCEINLINE I operator()(I first, I last, O dst)
const {
return std::copy(first,last,dst); }
177 template<
typename Cs,
typename IC1,
typename IC2> BOOST_FORCEINLINE
179 boost::gil::gil_function_requires<boost::gil::ChannelsCompatibleConcept<typename std::iterator_traits<IC1>::value_type,
typename std::iterator_traits<IC2>::value_type> >();
180 static_for_each(first,last,dst,boost::gil::detail::copy_fn<IC1,IC2>());
181 return dst+(last-first);
185 namespace boost {
namespace gil {
189 template <
typename I,
typename O>
191 BOOST_FORCEINLINE
void operator()(I src,
typename std::iterator_traits<I>::difference_type n, O dst)
const {
std::copy(src,src+n, dst); }
195 template <
typename IL,
typename O>
197 typedef typename std::iterator_traits<iterator_from_2d<IL> >::difference_type diff_t;
199 gil_function_requires<PixelLocatorConcept<IL> >();
200 gil_function_requires<MutablePixelIteratorConcept<O> >();
202 diff_t l=src.width()-src.x_pos();
203 diff_t numToCopy=(n<l ? n:l);
204 detail::copy_n(src.x(), numToCopy, dst);
213 template <
typename I,
typename OL>
215 typedef typename std::iterator_traits<I>::difference_type diff_t;
217 gil_function_requires<PixelIteratorConcept<I> >();
218 gil_function_requires<MutablePixelLocatorConcept<OL> >();
220 diff_t l=dst.width()-dst.x_pos();
221 diff_t numToCopy=(n<l ? n:l);
222 detail::copy_n(src, numToCopy, dst.x());
231 template <
typename IL,
typename OL>
233 typedef typename iterator_from_2d<IL>::difference_type diff_t;
235 gil_function_requires<PixelLocatorConcept<IL> >();
236 gil_function_requires<MutablePixelLocatorConcept<OL> >();
237 if (src.x_pos()!=dst.x_pos() || src.width()!=dst.width()) {
243 diff_t l=dst.width()-dst.x_pos();
244 diff_t numToCopy=(n<l ? n : l);
245 detail::copy_n(src.x(), numToCopy, dst.x());
253 template <
typename SrcIterator,
typename DstIterator>
254 BOOST_FORCEINLINE DstIterator copy_with_2d_iterators(SrcIterator first, SrcIterator last, DstIterator dst) {
255 typedef typename SrcIterator::x_iterator src_x_iterator;
256 typedef typename DstIterator::x_iterator dst_x_iterator;
258 typename SrcIterator::difference_type n = last - first;
260 if (first.is_1d_traversable()) {
261 if (dst.is_1d_traversable())
266 if (dst.is_1d_traversable())
267 copier_n<SrcIterator,dst_x_iterator>()(first,n, dst.x());
269 copier_n<SrcIterator,DstIterator>()(first,n,dst);
279 template <
typename IL,
typename OL>
281 return boost::gil::detail::copy_with_2d_iterators(first,last,dst);
285 namespace boost {
namespace gil {
288 template <
typename View1,
typename View2> BOOST_FORCEINLINE
290 assert(src.dimensions()==dst.dimensions());
291 detail::copy_with_2d_iterators(src.begin(),src.end(),dst.begin());
307 template <
typename CC>
308 class copy_and_convert_pixels_fn :
public binary_operation_obj<copy_and_convert_pixels_fn<CC> > {
312 typedef typename binary_operation_obj<copy_and_convert_pixels_fn<CC> >::result_type result_type;
313 copy_and_convert_pixels_fn() {}
314 copy_and_convert_pixels_fn(CC cc_in) : _cc(cc_in) {}
316 template <
typename V1,
typename V2> BOOST_FORCEINLINE
317 result_type apply_incompatible(
const V1& src,
const V2& dst)
const {
318 copy_pixels(color_converted_view<typename V2::value_type>(src,_cc),dst);
322 template <
typename V1,
typename V2> BOOST_FORCEINLINE
323 result_type apply_compatible(
const V1& src,
const V2& dst)
const {
330 template <
typename V1,
typename V2,
typename CC>
332 void copy_and_convert_pixels(
const V1& src,
const V2& dst,CC cc) {
333 detail::copy_and_convert_pixels_fn<CC> ccp(cc);
337 struct default_color_converter;
340 template <
typename View1,
typename View2>
342 void copy_and_convert_pixels(
const View1& src,
const View2& dst) {
343 detail::copy_and_convert_pixels_fn<default_color_converter> ccp;
367 template <
typename IL,
typename V>
369 boost::gil::gil_function_requires<boost::gil::MutablePixelLocatorConcept<IL> >();
370 if (first.is_1d_traversable()) {
374 std::ptrdiff_t n=last-first;
376 std::ptrdiff_t numToDo=std::min<const std::ptrdiff_t>(n,(std::ptrdiff_t)(first.width()-first.x_pos()));
377 fill_n(first.x(), numToDo, val);
385 namespace boost {
namespace gil {
389 template <
typename It,
typename P>
390 void operator()(It first, It last,
const P& p_in) {
395 template <
typename It,
typename P>
397 void fill_aux(It first, It last,
const P& p, mpl::true_) {
401 template <
typename It,
typename P>
403 void fill_aux(It first, It last,
const P& p,mpl::false_) {
410 template <
typename View,
typename Value> BOOST_FORCEINLINE
412 if (img_view.is_1d_traversable())
413 detail::fill_aux(img_view.begin().x(), img_view.end().x(),
414 val,is_planar<View>());
416 for (std::ptrdiff_t y=0; y<img_view.height(); ++y)
417 detail::fill_aux(img_view.row_begin(y),img_view.row_end(y),
418 val,is_planar<View>());
432 template <
typename It> BOOST_FORCEINLINE
433 void destruct_range_impl( It first
435 ,
typename enable_if< mpl::and_< is_pointer< It >
436 , mpl::not_< boost::has_trivial_destructor<
typename std::iterator_traits<It>::value_type > >
441 while (first!=last) {
447 template <
typename It> BOOST_FORCEINLINE
448 void destruct_range_impl( It
450 ,
typename enable_if< mpl::or_< mpl::not_< is_pointer< It > >
451 , boost::has_trivial_destructor<
typename std::iterator_traits< It >::value_type >
456 template <
typename It> BOOST_FORCEINLINE
457 void destruct_range(It first, It last) {
458 destruct_range_impl( first
463 struct std_destruct_t {
464 template <
typename It>
void operator()(It first, It last)
const { destruct_range(first,last); }
468 template <
typename It>
470 void destruct_aux(It first, It last, mpl::true_) {
471 static_for_each(first,last,std_destruct_t());
474 template <
typename It>
476 void destruct_aux(It first, It last, mpl::false_) {
477 destruct_range(first,last);
483 template <
typename View> BOOST_FORCEINLINE
485 if (img_view.is_1d_traversable())
486 detail::destruct_aux(img_view.begin().x(), img_view.end().x(),
489 for (std::ptrdiff_t y=0; y<img_view.height(); ++y)
490 detail::destruct_aux(img_view.row_begin(y),img_view.row_end(y),
507 template <
typename It,
typename P>
509 void uninitialized_fill_aux(It first, It last,
510 const P& p, mpl::true_) {
513 typedef typename std::iterator_traits<It>::value_type pixel_t;
514 while (channel < num_channels<pixel_t>::value) {
515 std::uninitialized_fill(dynamic_at_c(first,channel), dynamic_at_c(last,channel),
516 dynamic_at_c(p,channel));
520 for (
int c=0; c<channel; ++c)
521 destruct_range(dynamic_at_c(first,c), dynamic_at_c(last,c));
528 template <
typename It,
typename P>
530 void uninitialized_fill_aux(It first, It last,
531 const P& p,mpl::false_) {
532 std::uninitialized_fill(first,last,p);
540 template <
typename View,
typename Value>
542 if (img_view.is_1d_traversable())
543 detail::uninitialized_fill_aux(img_view.begin().x(), img_view.end().x(),
544 val,is_planar<View>());
546 typename View::y_coord_t y = 0;
548 for (y=0; y<img_view.height(); ++y)
549 detail::uninitialized_fill_aux(img_view.row_begin(y),img_view.row_end(y),
550 val,is_planar<View>());
552 for (
typename View::y_coord_t y0=0; y0<y; ++y0)
553 detail::destruct_aux(img_view.row_begin(y0),img_view.row_end(y0), is_planar<View>());
570 template <
typename It> BOOST_FORCEINLINE
571 void default_construct_range_impl(It first, It last, mpl::true_) {
572 typedef typename std::iterator_traits<It>::value_type value_t;
575 while (first!=last) {
576 new (first) value_t();
580 destruct_range(first1,first);
585 template <
typename It> BOOST_FORCEINLINE
586 void default_construct_range_impl(It, It, mpl::false_) {}
588 template <
typename It> BOOST_FORCEINLINE
589 void default_construct_range(It first, It last) { default_construct_range_impl(first, last,
typename is_pointer<It>::type()); }
592 template <
typename It>
594 void default_construct_aux(It first, It last, mpl::true_) {
597 typedef typename std::iterator_traits<It>::value_type pixel_t;
598 while (channel < num_channels<pixel_t>::value) {
599 default_construct_range(dynamic_at_c(first,channel), dynamic_at_c(last,channel));
603 for (
int c=0; c<channel; ++c)
604 destruct_range(dynamic_at_c(first,c), dynamic_at_c(last,c));
610 template <
typename It>
612 void default_construct_aux(It first, It last, mpl::false_) {
613 default_construct_range(first,last);
616 template <
typename View,
bool IsPlanar>
617 struct has_trivial_pixel_constructor :
public boost::has_trivial_constructor<typename View::value_type> {};
618 template <
typename View>
619 struct has_trivial_pixel_constructor<View, true> :
public boost::has_trivial_constructor<typename channel_type<View>::type> {};
623 template<
typename View,
bool B > BOOST_FORCEINLINE
624 void default_construct_pixels_impl(
const View& img_view
625 , boost::enable_if< is_same< mpl::bool_< B >
631 if( img_view.is_1d_traversable() )
633 detail::default_construct_aux( img_view.begin().x()
640 typename View::y_coord_t y = 0;
643 for( y = 0; y < img_view.height(); ++y )
645 detail::default_construct_aux( img_view.row_begin( y )
646 ,img_view.row_end( y )
652 for (
typename View::y_coord_t y0 = 0; y0 < y; ++y0 )
654 detail::destruct_aux( img_view.row_begin(y0)
655 , img_view.row_end(y0)
670 template <
typename View>
672 detail::default_construct_pixels_impl< View
673 , detail::has_trivial_pixel_constructor< View
674 , is_planar< View >::value
691 template <
typename It1,
typename It2>
693 void uninitialized_copy_aux(It1 first1, It1 last1,
694 It2 first2, mpl::true_) {
697 typedef typename std::iterator_traits<It1>::value_type pixel_t;
698 while (channel < num_channels<pixel_t>::value) {
699 std::uninitialized_copy(dynamic_at_c(first1,channel), dynamic_at_c(last1,channel), dynamic_at_c(first2,channel));
704 std::advance(last2, std::distance(first1,last1));
705 for (
int c=0; c<channel; ++c)
706 destruct_range(dynamic_at_c(first2,c), dynamic_at_c(last2,c));
711 template <
typename It1,
typename It2>
713 void uninitialized_copy_aux(It1 first1, It1 last1,
714 It2 first2,mpl::false_) {
715 std::uninitialized_copy(first1,last1,first2);
723 template <
typename View1,
typename View2>
725 typedef mpl::bool_<is_planar<View1>::value && is_planar<View2>::value> is_planar;
726 assert(view1.dimensions()==view2.dimensions());
727 if (view1.is_1d_traversable() && view2.is_1d_traversable())
728 detail::uninitialized_copy_aux(view1.begin().x(), view1.end().x(),
732 typename View1::y_coord_t y = 0;
734 for (y=0; y<view1.height(); ++y)
735 detail::uninitialized_copy_aux(view1.row_begin(y), view1.row_end(y),
739 for (
typename View1::y_coord_t y0=0; y0<y; ++y0)
740 detail::destruct_aux(view2.row_begin(y0),view2.row_end(y0), is_planar());
762 template <
typename V,
typename F>
763 F for_each_pixel(
const V& img, F fun) {
764 if (img.is_1d_traversable()) {
765 return std::for_each(img.begin().x(), img.end().x(), fun);
767 for (std::ptrdiff_t y=0; y<img.height(); ++y)
768 fun = std::for_each(img.row_begin(y),img.row_end(y),fun);
778 template <
typename View,
typename F>
779 F for_each_pixel_position(
const View& img, F fun) {
780 typename View::xy_locator loc=img.xy_at(0,0);
781 for (std::ptrdiff_t y=0; y<img.height(); ++y) {
782 for (std::ptrdiff_t x=0; x<img.width(); ++x, ++loc.x())
784 loc.x()-=img.width(); ++loc.y();
801 template <
typename View,
typename F>
803 if (v.is_1d_traversable()) {
804 std::generate(v.begin().x(), v.end().x(), fun);
806 for (std::ptrdiff_t y=0; y<v.height(); ++y)
807 std::generate(v.row_begin(y),v.row_end(y),fun);
821 template <
typename I1,
typename I2> BOOST_FORCEINLINE
bool equal_n(I1 i1, std::ptrdiff_t n, I2 i2);
824 template <
typename I1,
typename I2>
826 BOOST_FORCEINLINE
bool operator()(I1 i1, std::ptrdiff_t n, I2 i2)
const {
return std::equal(i1,i1+n, i2); }
831 template<
typename T,
typename Cs>
837 template<
typename T,
typename Cs>
843 template<
typename IC,
typename Cs>
846 std::ptrdiff_t numBytes=n*
sizeof(
typename std::iterator_traits<IC>::value_type);
848 for (std::ptrdiff_t i=0; i<mpl::size<Cs>::value; ++i)
849 if (memcmp(dynamic_at_c(i1,i), dynamic_at_c(i2,i), numBytes)!=0)
856 template <
typename Loc,
typename I2>
859 gil_function_requires<boost::gil::PixelLocatorConcept<Loc> >();
860 gil_function_requires<boost::gil::PixelIteratorConcept<I2> >();
862 std::ptrdiff_t num=std::min<const std::ptrdiff_t>(n, i1.width()-i1.x_pos());
863 if (!equal_n(i1.x(), num, i2))
874 template <
typename I1,
typename Loc>
877 gil_function_requires<boost::gil::PixelIteratorConcept<I1> >();
878 gil_function_requires<boost::gil::PixelLocatorConcept<Loc> >();
880 std::ptrdiff_t num=std::min<const std::ptrdiff_t>(n,i2.width()-i2.x_pos());
881 if (!equal_n(i1, num, i2.x()))
892 template <
typename Loc1,
typename Loc2>
895 gil_function_requires<boost::gil::PixelLocatorConcept<Loc1> >();
896 gil_function_requires<boost::gil::PixelLocatorConcept<Loc2> >();
897 if (i1.x_pos()!=i2.x_pos() || i1.width()!=i2.width()) {
899 if (*i1++!=*i2++)
return false;
903 std::ptrdiff_t num=std::min<const std::ptrdiff_t>(n,i2.width()-i2.x_pos());
904 if (!equal_n(i1.x(), num, i2.x()))
915 template <
typename I1,
typename I2> BOOST_FORCEINLINE
916 bool equal_n(I1 i1, std::ptrdiff_t n, I2 i2) {
917 return detail::equal_n_fn<I1,I2>()(i1,n,i2);
933 template <
typename Loc1,
typename Loc2> BOOST_FORCEINLINE
935 boost::gil::gil_function_requires<boost::gil::PixelLocatorConcept<Loc1> >();
936 boost::gil::gil_function_requires<boost::gil::PixelLocatorConcept<Loc2> >();
937 std::ptrdiff_t n=last-first;
938 if (first.is_1d_traversable()) {
939 if (first2.is_1d_traversable())
940 return boost::gil::detail::equal_n_fn<typename Loc1::x_iterator,typename Loc2::x_iterator>()(first.x(),n, first2.x());
942 return boost::gil::detail::equal_n_fn<typename Loc1::x_iterator,boost::gil::iterator_from_2d<Loc2> >()(first.x(),n, first2);
944 if (first2.is_1d_traversable())
952 namespace boost {
namespace gil {
955 template <
typename View1,
typename View2> BOOST_FORCEINLINE
957 assert(v1.dimensions()==v2.dimensions());
958 return std::equal(v1.begin(),v1.end(),v2.begin());
973 template <
typename View1,
typename View2,
typename F> BOOST_FORCEINLINE
975 assert(src.dimensions()==dst.dimensions());
976 for (std::ptrdiff_t y=0; y<src.height(); ++y) {
977 typename View1::x_iterator srcIt=src.row_begin(y);
978 typename View2::x_iterator dstIt=dst.row_begin(y);
979 for (std::ptrdiff_t x=0; x<src.width(); ++x)
980 dstIt[x]=fun(srcIt[x]);
987 template <
typename View1,
typename View2,
typename View3,
typename F> BOOST_FORCEINLINE
989 for (std::ptrdiff_t y=0; y<dst.height(); ++y) {
990 typename View1::x_iterator srcIt1=src1.row_begin(y);
991 typename View2::x_iterator srcIt2=src2.row_begin(y);
992 typename View3::x_iterator dstIt=dst.row_begin(y);
993 for (std::ptrdiff_t x=0; x<dst.width(); ++x)
994 dstIt[x]=fun(srcIt1[x],srcIt2[x]);
1005 template <
typename View1,
typename View2,
typename F> BOOST_FORCEINLINE
1007 assert(src.dimensions()==dst.dimensions());
1008 typename View1::xy_locator loc=src.xy_at(0,0);
1009 for (std::ptrdiff_t y=0; y<src.height(); ++y) {
1010 typename View2::x_iterator dstIt=dst.row_begin(y);
1011 for (std::ptrdiff_t x=0; x<src.width(); ++x, ++loc.x())
1013 loc.x()-=src.width(); ++loc.y();
1020 template <
typename View1,
typename View2,
typename View3,
typename F> BOOST_FORCEINLINE
1022 assert(src1.dimensions()==dst.dimensions());
1023 assert(src2.dimensions()==dst.dimensions());
1024 typename View1::xy_locator loc1=src1.xy_at(0,0);
1025 typename View2::xy_locator loc2=src2.xy_at(0,0);
1026 for (std::ptrdiff_t y=0; y<src1.height(); ++y) {
1027 typename View3::x_iterator dstIt=dst.row_begin(y);
1028 for (std::ptrdiff_t x=0; x<src1.width(); ++x, ++loc1.x(), ++loc2.x())
1029 dstIt[x]=fun(loc1,loc2);
1030 loc1.x()-=src1.width(); ++loc1.y();
1031 loc2.x()-=src2.width(); ++loc2.y();
void uninitialized_fill_pixels(const View &img_view, const Value &val)
std::uninitialized_fill for image views. Does not support planar heterogeneous views. If an exception is thrown destructs any in-place copy-constructed pixels
Definition: algorithm.hpp:541
Represents a pixel value (a container of channels). Models: HomogeneousColorBaseValueConcept, PixelValueConcept, HomogeneousPixelBasedConcept.
Definition: metafunctions.hpp:44
void generate_pixels(const View &v, F fun)
std::generate for image views
Definition: algorithm.hpp:802
An iterator over planar pixels. Models HomogeneousColorBaseConcept, PixelIteratorConcept, HomogeneousPixelBasedConcept, MemoryBasedIteratorConcept, HasDynamicXStepTypeConcept.
Definition: algorithm.hpp:53
Concept check classes for GIL concepts.
Definition: algorithm.hpp:190
Provides 1D random-access navigation to the pixels of the image. Models: PixelIteratorConcept, PixelBasedConcept, HasDynamicXStepTypeConcept.
Definition: iterator_from_2d.hpp:52
Memory-based pixel locator. Models: PixelLocatorConcept,HasDynamicXStepTypeConcept,HasDynamicYStepTypeConcept,HasTransposedTypeConceptThe class takes a step iterator as a parameter. The step iterator provides navigation along the vertical axis while its base iterator provides horizontal navigation.
Definition: algorithm.hpp:57
BOOST_FORCEINLINE bool equal_pixels(const View1 &v1, const View2 &v2)
std::equal for image views
Definition: algorithm.hpp:956
void fill(boost::gil::iterator_from_2d< IL > first, boost::gil::iterator_from_2d< IL > last, const V &val)
std::fill(I,I,V) with I being a iterator_from_2d
Definition: algorithm.hpp:368
Returns whether two views are compatible.
Definition: gil_concept.hpp:2050
BOOST_FORCEINLINE void copy_pixels(const View1 &src, const View2 &dst)
std::copy for image views
Definition: algorithm.hpp:289
BOOST_FORCEINLINE void fill_pixels(const View &img_view, const Value &val)
std::fill for image views
Definition: algorithm.hpp:411
void default_construct_pixels(const View &img_view)
Invokes the in-place default constructor on every pixel of the (uninitialized) view. Does not support planar heterogeneous views. If an exception is thrown destructs any in-place default-constructed pixels.
Definition: algorithm.hpp:671
BOOST_FORCEINLINE boost::gil::iterator_from_2d< OL > copy1(boost::gil::iterator_from_2d< IL > first, boost::gil::iterator_from_2d< IL > last, boost::gil::iterator_from_2d< OL > dst)
std::copy(I1,I1,I2) with I1 and I2 being a iterator_from_2d
Definition: algorithm.hpp:280
BOOST_FORCEINLINE boost::gil::planar_pixel_iterator< IC2, Cs > copy(boost::gil::planar_pixel_iterator< IC1, Cs > first, boost::gil::planar_pixel_iterator< IC1, Cs > last, boost::gil::planar_pixel_iterator< IC2, Cs > dst)
Copy when both src and dst are planar pointers is copy for each channel.
Definition: algorithm.hpp:178
BOOST_FORCEINLINE bool equal(boost::gil::iterator_from_2d< Loc1 > first, boost::gil::iterator_from_2d< Loc1 > last, boost::gil::iterator_from_2d< Loc2 > first2)
std::equal(I1,I1,I2) with I1 and I2 being a iterator_from_2d
Definition: algorithm.hpp:934
A generic binary operation on viewsUse this class as a convenience superclass when defining an operat...
Definition: algorithm.hpp:100
struct to do std::fill
Definition: algorithm.hpp:388
void uninitialized_copy_pixels(const View1 &view1, const View2 &view2)
std::uninitialized_copy for image views. Does not support planar heterogeneous views. If an exception is thrown destructs any in-place copy-constructed objects
Definition: algorithm.hpp:724
Methods for constructing image views from raw data or other image views /.
BOOST_FORCEINLINE void destruct_pixels(const View &img_view)
Invokes the in-place destructor on every pixel of the view.
Definition: algorithm.hpp:484
MEMORY-BASED STEP ITERATOR.
Definition: algorithm.hpp:55
A model of a heterogeneous pixel that is not byte aligned. Examples are bitmap (1-bit pixels) or 6-bi...